@dokebi/cli 0.4.2 → 0.4.26

package/dist/recipe-mail.js

@@ -0,0 +1,214 @@
+// Local development mail is an explicit recipe choice (D-0078 MP4).
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { debug, isMissing } from './diagnostics.js';
+import { CliError } from './errors.js';
+const exec = promisify(execFile);
+export const MAIL_COMPOSE = 'compose.mail.yaml';
+const CONNECTION = 'recipeMail';
+const QUEUE = 'recipeMail';
+/** Omitting ports reproduces the legacy template for safe migration only. */
+export function mailCompose(root, ports) {
+    const name = `dokebi-mail-${createHash('sha256').update(root).digest('hex').slice(0, 12)}`;
+    return `# Local mail only. Never deploy this file to production.\nname: ${name}\nservices:\n  mailpit:\n    image: axllent/mailpit:v1.31.4\n    ports: ["127.0.0.1:${ports?.smtp ?? ''}:1025", "127.0.0.1:${ports?.inbox ?? ''}:8025"]\n  nats:\n    image: nats:2.11.8-alpine\n    command: ["-js", "-sd", "/data"]\n    ports: ["127.0.0.1:${ports?.nats ?? ''}:4222"]\n    volumes: ["mail-jobs:/data"]\nvolumes:\n  mail-jobs: {}\n`;
+}
+async function docker(root, args) {
+    debug('Recipe mail Docker command', { args });
+    try {
+        return (await exec('docker', ['compose', '-f', MAIL_COMPOSE, ...args], {
+            cwd: root,
+            timeout: 120_000,
+            maxBuffer: 64 * 1024,
+        })).stdout.trim();
+    }
+    catch (cause) {
+        throw new CliError('MAIL_INFRA_FAILED', 'The local mail environment could not be prepared', {
+            cause,
+            details: {
+                fix: `Inspect docker compose -f ${MAIL_COMPOSE} ps and logs; rerun the same recipe after fixing it.`,
+            },
+        });
+    }
+}
+async function port(root, service, target) {
+    const address = await docker(root, ['port', service, String(target)]);
+    const matched = /^127\.0\.0\.1:(\d+)$/.exec(address);
+    const value = Number(matched?.[1]);
+    if (!Number.isInteger(value) || value < 1 || value > 65535)
+        throw new CliError('MAIL_INFRA_FAILED', 'Docker did not publish a loopback mail port');
+    return value;
+}
+/** Accept only an untouched generated template; never infer ownership from a filename. */
+export function mailComposePorts(root, source) {
+    if (source === mailCompose(root))
+        return undefined;
+    const matches = [...source.matchAll(/127\.0\.0\.1:(\d+):(1025|8025|4222)/g)];
+    const values = Object.fromEntries(matches.map((match) => [match[2], Number(match[1])]));
+    const ports = {
+        smtp: values['1025'] ?? 0,
+        inbox: values['8025'] ?? 0,
+        nats: values['4222'] ?? 0,
+    };
+    if (matches.length !== 3 ||
+        Object.values(ports).some((value) => value < 1 || value > 65535) ||
+        new Set(Object.values(ports)).size !== 3 ||
+        source !== mailCompose(root, ports))
+        throw new CliError('RECIPE_FILE_CONFLICT', `${MAIL_COMPOSE} was edited; configure mail manually instead of replacing it`);
+    return ports;
+}
+async function existingMailCompose(root) {
+    try {
+        return await readFile(join(root, MAIL_COMPOSE), 'utf8');
+    }
+    catch (error) {
+        if (!isMissing(error))
+            throw error;
+        return undefined;
+    }
+}
+export async function checkMailCompose(root) {
+    const source = await existingMailCompose(root);
+    if (source !== undefined)
+        mailComposePorts(root, source);
+}
+/** Reserve three distinct loopback ports together, then persist them before Docker starts. */
+export async function allocateMailPorts() {
+    const servers = [createServer(), createServer(), createServer()];
+    const ports = [];
+    try {
+        for (const server of servers) {
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(0, '127.0.0.1', resolve);
+            });
+            ports.push(server.address().port);
+        }
+        const [smtp, inbox, nats] = ports;
+        if (!smtp || !inbox || !nats)
+            throw new CliError('MAIL_INFRA_FAILED', 'Could not allocate development mail ports');
+        debug('Allocated persistent development mail ports', { smtp, inbox, nats });
+        return { smtp, inbox, nats };
+    }
+    catch (cause) {
+        throw new CliError('MAIL_INFRA_FAILED', 'Could not reserve development mail ports', { cause });
+    }
+    finally {
+        await Promise.all(servers
+            .filter((server) => server.listening)
+            .map((server) => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))));
+    }
+}
+export function mailSteps(input) {
+    const { root, project, choice, now } = input;
+    if (!choice || choice === 'none')
+        return [];
+    if (choice !== 'mailpit')
+        return [];
+    const has = async (id) => (await now())?.installed.has(id) ?? false;
+    return [
+        {
+            id: 'mail-infra',
+            command: `docker compose -f ${MAIL_COMPOSE} up -d --wait`,
+            why: 'local Mailpit and a dedicated NATS JetStream, free loopback ports persisted in Compose before startup; compose.yaml is kept',
+            satisfied: async () => false,
+            run: async () => {
+                const existing = await existingMailCompose(root);
+                const configured = existing === undefined ? undefined : mailComposePorts(root, existing);
+                const selected = configured ?? (await allocateMailPorts());
+                const content = mailCompose(root, selected);
+                await project.writeRecipeFiles(root, existing !== undefined && !configured
+                    ? {
+                        files: [],
+                        edits: [
+                            {
+                                path: MAIL_COMPOSE,
+                                edit(text) {
+                                    if (text !== existing)
+                                        throw new CliError('RECIPE_FILE_CONFLICT', `${MAIL_COMPOSE} changed while the recipe was writing it`, {
+                                            details: {
+                                                path: MAIL_COMPOSE,
+                                                fix: `${MAIL_COMPOSE} was edited during the run: run the same recipe command again`,
+                                            },
+                                            phase: 'plan',
+                                        });
+                                    return content;
+                                },
+                            },
+                        ],
+                    }
+                    : { files: [{ path: MAIL_COMPOSE, content }] });
+                await docker(root, ['up', '-d', '--wait']);
+                const natsPort = await port(root, 'nats', 4222);
+                const smtpPort = await port(root, 'mailpit', 1025);
+                const uiPort = await port(root, 'mailpit', 8025);
+                const connection = { servers: [`nats://localhost:${natsPort}`] };
+                const queue = {
+                    connection: CONNECTION,
+                    stream: 'DOKEBI_MAIL',
+                    consumer: 'DOKEBI_MAIL_WORKER',
+                    subject: 'dokebi.mail',
+                    deadLetterStream: 'DOKEBI_MAIL_DLQ',
+                    deadLetterSubject: 'dokebi.mail.dead',
+                };
+                const transport = { driver: 'smtp', host: 'localhost', port: smtpPort, tls: 'off' };
+                // This explicit choice owns only its named development connection and queue.
+                if (!(await has('dokebi-nats')))
+                    await project.add(root, '@dokebi/nats', false, [
+                        { path: ['connections', CONNECTION], value: connection },
+                    ]);
+                else
+                    await project.configSet(root, [
+                        {
+                            plugin: 'dokebi-nats',
+                            set: { path: ['connections', CONNECTION], value: connection },
+                        },
+                    ]);
+                if (!(await has('dokebi-job')))
+                    await project.add(root, '@dokebi/job', false, [
+                        { path: ['queues', QUEUE], value: queue },
+                    ]);
+                else
+                    await project.configSet(root, [
+                        { plugin: 'dokebi-job', set: { path: ['queues', QUEUE], value: queue } },
+                    ]);
+                if (!(await has('dokebi-mail')))
+                    await project.add(root, '@dokebi/mail', false, [
+                        { path: ['transport'], value: transport },
+                        { path: ['queue'], value: QUEUE },
+                    ]);
+                else
+                    await project.configSet(root, [
+                        { plugin: 'dokebi-mail', set: { path: ['transport'], value: transport } },
+                        { plugin: 'dokebi-mail', set: { path: ['queue'], value: QUEUE } },
+                    ]);
+                debug('Recipe local mail configured', {
+                    smtpPort,
+                    natsPort,
+                    inbox: `http://localhost:${uiPort}`,
+                });
+            },
+        },
+        {
+            id: 'mail-provision',
+            command: `npx dokebi-job-provision --queue ${QUEUE}`,
+            why: 'provision the dedicated mail stream and durable consumer before starting',
+            satisfied: async () => false,
+            run: async () => {
+                try {
+                    await exec(join(root, 'node_modules/.bin/dokebi-job-provision'), ['--queue', QUEUE], {
+                        cwd: root,
+                        timeout: 30_000,
+                        maxBuffer: 64 * 1024,
+                    });
+                }
+                catch (cause) {
+                    throw new CliError('MAIL_QUEUE_REQUIRED', 'The local mail queue could not be provisioned', { cause });
+                }
+            },
+        },
+    ];
+}

package/dist/recipe-members.d.ts

@@ -0,0 +1,35 @@
+import type { LoginDialect, LoginFile } from './recipe-login.js';
+/** The names the login code uses for the app's own user table. */
+export interface LoginNames {
+    /** The table (MongoDB: collection) of the app's users. */
+    readonly table: string;
+    /** The migration name, `<UTC time>_<migration>.ts`. */
+    readonly migration: string;
+    /** The numeric primary key column (SQL). */
+    readonly id: string;
+    /** The row type of the model (`Member`). */
+    readonly type: string;
+    /** A row as a variable (`member`), and the collection field of the MongoDB model. */
+    readonly row: string;
+    readonly rows: string;
+    /** The role a new row gets, and the ability that role has in authorize. */
+    readonly role: string;
+    readonly ability: string;
+    /** What the admin page says to a user with that ability. */
+    readonly mayWrite: string;
+}
+/**
+ * New projects (D-0115): app_members, the table of the app's sign-in accounts behind
+ * MembersModel. The app_ prefix keeps it apart from the users or members table an app often has
+ * of its own; the default role member may write content (content.write).
+ */
+export declare const LOGIN_NAMES: LoginNames;
+/** What recipes before D-0115 wrote (the blog's authors); such projects keep them. */
+export declare const LEGACY_LOGIN_NAMES: LoginNames;
+/** The table of new projects (LOGIN_NAMES.table). */
+export declare const USERS_TABLE: string;
+export declare const MEMBER_MODEL = "src/shared/models/members.ts";
+export declare const MEMBER_SERVICE = "src/shared/services/members.ts";
+/** Separate files, not layer classes grouped together in the auth extension. */
+export declare function memberFiles(dialect: LoginDialect, n?: LoginNames): LoginFile[];
+export declare function memberExtension(dialect: LoginDialect, n?: LoginNames): string;

package/dist/recipe-members.js

@@ -0,0 +1,178 @@
+/**
+ * New projects (D-0115): app_members, the table of the app's sign-in accounts behind
+ * MembersModel. The app_ prefix keeps it apart from the users or members table an app often has
+ * of its own; the default role member may write content (content.write).
+ */
+export const LOGIN_NAMES = {
+    table: 'app_members',
+    migration: 'create_app_members',
+    id: 'member_no',
+    type: 'Member',
+    row: 'member',
+    rows: 'members',
+    role: 'member',
+    ability: 'content.write',
+    mayWrite: 'You may write content.',
+};
+/** What recipes before D-0115 wrote (the blog's authors); such projects keep them. */
+export const LEGACY_LOGIN_NAMES = {
+    table: 'blog_authors',
+    migration: 'create_blog_authors',
+    id: 'author_no',
+    type: 'Author',
+    row: 'author',
+    rows: 'authors',
+    role: 'author',
+    ability: 'posts.write',
+    mayWrite: 'You may write posts.',
+};
+/** The table of new projects (LOGIN_NAMES.table). */
+export const USERS_TABLE = LOGIN_NAMES.table;
+export const MEMBER_MODEL = 'src/shared/models/members.ts';
+export const MEMBER_SERVICE = 'src/shared/services/members.ts';
+function sqlModel(dialect, n) {
+    const driver = dialect === 'postgres' ? 'pg' : dialect === 'mysql' ? 'mysql2/promise' : 'mariadb';
+    const mark = (n) => (dialect === 'postgres' ? `$${n}` : '?');
+    const select = (column, value) => {
+        const sql = `SELECT ${n.id}, login_name, pass_phc, logout_key, is_active, role FROM ${n.table} WHERE ${column} = ${mark(1)}`;
+        if (dialect === 'postgres')
+            return `const { rows } = await this.#pool.query<${n.type}>('${sql}', [${value}]);\n    return rows[0];`;
+        if (dialect === 'mysql')
+            return `const [rows] = await this.#pool.query<(${n.type} & RowDataPacket)[]>('${sql}', [${value}]);\n    return rows[0];`;
+        return `const rows = await this.#pool.query<${n.type}[]>('${sql}', [${value}]);\n    return rows[0];`;
+    };
+    return `import type { Pool${dialect === 'mysql' ? ', RowDataPacket' : ''} } from '${driver}';
+
+export type ${n.type} = {
+  ${n.id}: number;
+  login_name: string;
+  pass_phc: string | null;
+  logout_key: string;
+  is_active: ${dialect === 'postgres' ? 'boolean' : 'number | boolean'};
+  role: string;
+};
+
+export class MembersModel {
+  readonly #pool: Pool;
+  constructor(pool: Pool) { this.#pool = pool; }
+
+  async findByIdentity(identity: string): Promise<${n.type} | undefined> {
+    ${select('login_name', 'identity')}
+  }
+  async findById(id: string): Promise<${n.type} | undefined> {
+    if (!/^\\d{1,15}$/.test(id)) return undefined;
+    ${select(n.id, 'Number(id)')}
+  }
+  async updatePasswordHash(${n.row}: ${n.type}, hash: string, stamp: string): Promise<void> {
+    await this.#pool.query('UPDATE ${n.table} SET pass_phc = ${mark(1)}, logout_key = ${mark(2)} WHERE ${n.id} = ${mark(3)}', [hash, stamp, ${n.row}.${n.id}]);
+  }
+}
+`;
+}
+const MONGO_MODEL = (n) => `import { type Collection, type MongoClient, ObjectId } from 'mongodb';
+
+export type ${n.type} = {
+  _id: ObjectId;
+  login_name: string;
+  pass_phc: string | null;
+  logout_key: string;
+  is_active: boolean;
+  role: string;
+};
+
+export class MembersModel {
+  readonly #${n.rows}: Collection<${n.type}>;
+  constructor(client: MongoClient) {
+    this.#${n.rows} = client.db().collection<${n.type}>('${n.table}');
+  }
+  async findByIdentity(identity: string): Promise<${n.type} | undefined> {
+    return (await this.#${n.rows}.findOne({ login_name: identity })) ?? undefined;
+  }
+  async findById(id: string): Promise<${n.type} | undefined> {
+    if (!/^[0-9a-f]{24}$/.test(id)) return undefined;
+    return (await this.#${n.rows}.findOne({ _id: new ObjectId(id) })) ?? undefined;
+  }
+  async updatePasswordHash(${n.row}: ${n.type}, hash: string, stamp: string): Promise<void> {
+    await this.#${n.rows}.updateOne({ _id: ${n.row}._id }, { $set: { pass_phc: hash, logout_key: stamp } });
+  }
+}
+`;
+const SERVICE = (n) => `import { randomBytes } from 'node:crypto';
+import type { ${n.type}, MembersModel } from '../models/members.ts';
+
+/** Data and credential-update workflows, independent of HTTP and auth hook context. */
+export class MembersService {
+  readonly #model: MembersModel;
+  constructor(model: MembersModel) { this.#model = model; }
+
+  findByIdentity(identity: string): Promise<${n.type} | undefined> {
+    return this.#model.findByIdentity(identity.trim().toLowerCase());
+  }
+  findById(id: string): Promise<${n.type} | undefined> {
+    return this.#model.findById(id);
+  }
+  updatePasswordHash(${n.row}: ${n.type}, hash: string, reset: boolean): Promise<void> {
+    // Reset invalidates other sessions; an automatic hash upgrade preserves their stamp.
+    const stamp = reset ? randomBytes(16).toString('base64url') : ${n.row}.logout_key;
+    return this.#model.updatePasswordHash(${n.row}, hash, stamp);
+  }
+}
+`;
+/** Separate files, not layer classes grouped together in the auth extension. */
+export function memberFiles(dialect, n = LOGIN_NAMES) {
+    return [
+        { path: MEMBER_MODEL, content: dialect === 'mongodb' ? MONGO_MODEL(n) : sqlModel(dialect, n) },
+        { path: MEMBER_SERVICE, content: SERVICE(n) },
+    ];
+}
+export function memberExtension(dialect, n = LOGIN_NAMES) {
+    const id = dialect === 'mongodb' ? `${n.row}._id.toHexString()` : `String(${n.row}.${n.id})`;
+    return `// Auth wiring: data is provided by MembersService through MembersModel.
+// Password hashing/checking and auth token lifecycle remain owned by @dokebi/auth.
+import { AuthExtension, type AuthHookContext, type AuthPasswordChange, type AuthUser } from '@dokebi/auth';
+import type { PluginDependency } from '@dokebi/core';
+import { dependency as db } from '@dokebi/db';
+import { type ${n.type}, MembersModel } from '../../shared/models/members.ts';
+import { MembersService } from '../../shared/services/members.ts';
+import { main } from '../db/connections.ts';
+
+const ROLE_ABILITIES: Readonly<Record<string, readonly string[]>> = {
+  ${n.role}: ['${n.ability}'],
+};
+
+export default class AppAuth extends AuthExtension<${n.type}> {
+  #members: MembersService | undefined;
+  protected override dependencies(): readonly PluginDependency[] { return [db]; }
+
+  // The extension has no setup hook. Cache the stateless composition on its first hook call,
+  // after dependency setup; this uses the provider's existing pool and creates no connections.
+  #service(context: AuthHookContext): MembersService {
+    return (this.#members ??= new MembersService(new MembersModel(context.getDependency(db).connection(main))));
+  }
+  protected override findByIdentity(identity: string, context: AuthHookContext) {
+    return this.#service(context).findByIdentity(identity);
+  }
+  protected override findById(id: string, context: AuthHookContext) {
+    return this.#service(context).findById(id);
+  }
+  protected override credentials(${n.row}: ${n.type}): AuthUser {
+    return {
+      id: ${id},
+      passwordHash: ${n.row}.pass_phc,
+      email: ${n.row}.login_name.includes('@') ? ${n.row}.login_name : undefined,
+      stamp: ${n.row}.logout_key,
+      active: Boolean(${n.row}.is_active),
+    };
+  }
+  protected override updatePasswordHash(${n.row}: ${n.type}, hash: string, context: AuthHookContext, change: AuthPasswordChange) {
+    return this.#service(context).updatePasswordHash(${n.row}, hash, change.reason === 'reset');
+  }
+  protected override authorize(${n.row}: ${n.type}, ability: string): boolean {
+    return ${n.row}.role === 'admin' || (ROLE_ABILITIES[${n.row}.role]?.includes(ability) ?? false);
+  }
+  protected override viewUser(${n.row}: ${n.type}) {
+    return { id: ${id}, login: ${n.row}.login_name, role: ${n.row}.role };
+  }
+}
+`;
+}

package/dist/recipe-record.d.ts

@@ -1,24 +1,99 @@
 export declare const RECIPE_RECORD = ".dokebi/recipe.json";
+/**
+ * How the agent passes `tellUser` on (AI-M05 F6: an agent summarized the lines in another
+ * language instead of relaying them): verify's JSON carries it next to the lines, the human
+ * output prints it as the block's heading.
+ */
+export declare const TELL_USER_RELAY: {
+    readonly tellUser: 'verbatim';
+    readonly instruction: 'Copy these lines unchanged into your final message to the user: do not translate, reword or summarize them. You may add your own summary after them.';
+};
+/** Stands for `<scheme>://<domain>:<port>` of the app in a recorded notice. */
+export declare const APP_URL_PLACEHOLDER = "{appUrl}";
+/** Stands for the first admin's login and password key in the login notice (firstAdminPhrase). */
+export declare const FIRST_ADMIN_PLACEHOLDER = "{firstAdmin}";
+/** What the login notice says about protected pages (D-0115: no word of one kind of app). */
+export declare const LOGIN_PAGES = "pages that need a login send other visitors to the login page.";
 export interface RecordedAnswer {
     readonly value: string;
-    readonly answeredBy: 'flag' | 'default' | 'recipe';
+    /** D-0095: `user`, `ai` (with `aiReason` when the agent gave one), `default`, `recipe`. */
+    readonly answeredBy: 'user' | 'ai' | 'default' | 'recipe';
     readonly defaultReason?: string;
+    readonly aiReason?: string;
 }
 export interface AppliedRecipe {
     readonly recipe: string;
     readonly appliedAt: string;
-    /** `user`: the user answered; `defaults`: the user left the choices to the agent. */
+    /**
+     * `user`: the given answers are the user's (except those the agent chose, `answeredBy: ai`);
+     * `defaults`: the user left every choice to the agent.
+     */
     readonly answersFrom: 'user' | 'defaults';
     readonly answers: Readonly<Record<string, RecordedAnswer>>;
-    /** What the user must know about the result (one line each). */
+    /** What the user must know about the result (one line each; APP_URL_PLACEHOLDER for the app). */
     readonly notices: readonly string[];
+    /** The domain the recipe serves the app on (`localhost`): picks the address for the notices. */
+    readonly domain?: string;
+}
+/** Where the app answers now: verify's `urls`, else the port of dokebi.yaml. */
+export interface AppAddress {
+    readonly urls: readonly string[];
+    readonly port?: number;
+}
+/**
+ * D-0098: a product choice made outside a recipe: the view of an app that `dokebi app add` (or
+ * the first app of `dokebi add <apps host>`) created. `unstated`: an EJS app added without saying
+ * who chose it; EJS is not the default view (Inertia + Vue), so the user hears about it.
+ */
+export interface RecordedChoice {
+    readonly app: string;
+    readonly id: 'view';
+    /** A value of the view question: `ejs`, `inertia-vue`, `inertia-vue-ssr`. */
+    readonly value: string;
+    readonly answeredBy: 'user' | 'ai' | 'unstated';
+    readonly aiReason?: string;
+    readonly recordedAt: string;
 }
 /** The recipes recorded in the project; none when there is no record (or it is unreadable). */
 export declare function readAppliedRecipes(root: string): Promise<AppliedRecipe[]>;
-/** Records an applied recipe, replacing an earlier application of the same recipe. */
-export declare function saveAppliedRecipe(root: string, entry: AppliedRecipe): Promise<void>;
+/** D-0098: the choices recorded outside recipes (the views of apps). */
+export declare function readRecordedChoices(root: string): Promise<RecordedChoice[]>;
+/**
+ * Records an applied recipe, replacing an earlier application of the same recipe. The recorded
+ * app choices of `apps` (the apps the recipe answers for) give way to the recipe's answers.
+ */
+export declare function saveAppliedRecipe(root: string, entry: AppliedRecipe, apps?: readonly string[]): Promise<void>;
+/**
+ * `dokebi app remove`: drops the choices recorded for `app`. True when the record changed (the
+ * file is left alone when it holds none of that app).
+ */
+export declare function forgetAppChoices(root: string, app: string): Promise<boolean>;
+/** D-0098: records the view of an app made outside a recipe, replacing that app's earlier one. */
+export declare function saveRecordedChoice(root: string, choice: RecordedChoice): Promise<void>;
+/** Whether a recorded notice names the first admin (filled from the project by verify). */
+export declare function namesFirstAdmin(notice: string): boolean;
+/** The same part as the recipe says it now: what the recipe built, true whatever comes later. */
+export declare const NO_SCREENS_BUILT = "the recipe built a JSON API for other programs, with no pages where people sign up, browse or press buttons.";
+/**
+ * One recorded notice as the user hears it now. A fact notice (D-0137) is the text verify read
+ * from the project (`facts`, by factKey), or, without it, that the CLI could not read it; '' when
+ * nothing is left to say. Any other notice gets the current app address: the placeholder filled
+ * in, or (a record from before the placeholder) a loopback address whose port is not the app's
+ * replaced by the current one; without a current address the placeholder becomes
+ * `http://<domain>`. The first admin placeholder gets `firstAdmin` (D-0115).
+ */
+export declare function fillNotice(notice: string, entry: AppliedRecipe, address: AppAddress, firstAdmin?: string, facts?: ReadonlyMap<string, string>): string;
+/** What the user hears about an answer the agent chose (D-0095), with its reason when given. */
+export declare const AI_CHOICE_LINE = "chosen by the AI (you left the choice to it)";
+/** D-0098: an EJS app added without saying who chose EJS. */
+export declare const UNSTATED_VIEW_LINE = "not the default view (Inertia + Vue), and who chose it was not recorded";
 /**
  * The lines for the user's final message: each answer and who chose it (a default with its
- * reason), then the notices. Answers fixed by the recipe itself are not choices and are left out.
+ * reason, an AI choice with the agent's reason when it gave one), then the notices with the
+ * current app address. Answers fixed by the recipe itself are not choices and are left out.
  */
-export declare function tellUserLines(recipes: readonly AppliedRecipe[]): string[];
+export declare function tellUserLines(recipes: readonly AppliedRecipe[], address?: AppAddress, choices?: readonly RecordedChoice[], 
+/** firstAdminPhrase of the project now (D-0115); without it, the not-found words. */
+firstAdmin?: string, 
+/** D-0137: the fact notices as verify read them from the project (factTexts). */
+facts?: ReadonlyMap<string, string>): string[];