@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/brain/brain.js

@@ -0,0 +1,624 @@
+/**
+ * Le cerveau de Prométhée : conversation avec le modèle local, propositions de commandes,
+ * et reprise de la réponse après la décision de l'utilisateur.
+ *
+ * Le modèle ne peut rien exécuter. Son seul outil crée une proposition ; c'est l'appel à
+ * decide(), déclenché par un clic de l'utilisateur, qui lance la commande via le moteur.
+ */
+import { randomBytes } from 'node:crypto';
+import { AppError, badRequest, describeError } from '../errors.js';
+import { READ_BUDGET_MS, pagesToRead, recallExtracts, searchExtracts } from '../savoir/memoire.js';
+import { anchorAccepted, anchorCandidates, detectMany, zoneOf } from '../search/categories.js';
+import { cut, placeCandidates } from '../search/searxng.js';
+import { COMMAND_TOOL, RECALL_TOOL_NAME, ROUTER_SCHEMA, ROUTER_SYSTEM, SEARCH_ROUTER_SCHEMA, SEARCH_ROUTER_SYSTEM, SEARCH_TOOL_NAME, TOOL_NAME, autoRunRules, extractsText, recallResultText, recallRules, refusalText, searchAnswerRules, searchResultText, searchRouterInput, systemPrompt, toolResultText, unverifiedValues, } from './prompt.js';
+/** Commandes au plus qu'un seul tour auto enchaîne tout seul, avant de s'arrêter par sécurité. */
+const MAX_AUTO_STEPS = 20;
+const plural = (n, one, many) => `${n} ${n > 1 ? many : one}`;
+const MAX_REFUSALS = 3;
+const id16 = () => randomBytes(8).toString('hex');
+function proposalResult(p) {
+    switch (p.status) {
+        case 'refused':
+            return refusalText(p.verdict);
+        case 'denied':
+            return "L'utilisateur a refusé cette commande. Ne la repropose pas telle quelle : demande-lui ce qu'il préfère ou propose autre chose.";
+        case 'done':
+        case 'failed':
+            return p.result ? toolResultText(p.result) : 'Commande terminée sans résultat enregistré.';
+        default:
+            return "L'utilisateur n'a pas répondu à cette proposition.";
+    }
+}
+/** Le message de l'utilisateur tel que le modèle le lit : le texte tapé, puis chaque pièce jointe sous un en-tête qui la nomme. */
+export function userText(m) {
+    const parts = m.content.trim() ? [m.content] : [];
+    for (const a of m.attachments ?? [])
+        parts.push(`[Fichier joint : ${a.name}]\n${a.text}`);
+    return parts.join('\n\n');
+}
+/**
+ * Reconstruit l'historique au format du modèle à partir des messages enregistrés.
+ *
+ * Les passages lus dans les pages ne sont donnés qu'à la réponse qui suit leur recherche ou leur rappel (le message est
+ * alors le dernier de l'historique), toujours produite sans l'outil de commande. Plus loin dans la conversation, il ne
+ * reste que la liste des résultats : un long texte venu d'internet ne reste pas sous les yeux du modèle quand il peut
+ * proposer des commandes, et la fenêtre de contexte n'en est pas encombrée.
+ */
+export function toTurns(conversation) {
+    const turns = [];
+    const lastIndex = conversation.messages.length - 1;
+    conversation.messages.forEach((m, i) => {
+        if (m.role === 'user')
+            turns.push({ role: 'user', content: userText(m) });
+        else if (m.search) {
+            // La recherche se présente au modèle comme un appel d'outil suivi de son résultat
+            const args = { requete: m.search.query, ...(m.search.placeQuery ? { lieu: m.search.placeQuery } : {}) };
+            turns.push({ role: 'assistant', content: '', toolCalls: [{ name: SEARCH_TOOL_NAME, arguments: args }] });
+            turns.push({ role: 'tool', toolName: SEARCH_TOOL_NAME, content: searchResultText(m.search, i === lastIndex) });
+        }
+        else if (m.recall) {
+            if (i !== lastIndex)
+                return;
+            turns.push({ role: 'assistant', content: '', toolCalls: [{ name: RECALL_TOOL_NAME, arguments: { question: m.recall.query } }] });
+            turns.push({ role: 'tool', toolName: RECALL_TOOL_NAME, content: recallResultText(m.recall) });
+        }
+        else if (m.proposal) {
+            turns.push({ role: 'assistant', content: m.content, toolCalls: [{ name: TOOL_NAME, arguments: { commande: m.proposal.command, explication: m.proposal.explanation } }] });
+            turns.push({ role: 'tool', toolName: TOOL_NAME, content: proposalResult(m.proposal) });
+        }
+        else if (m.content)
+            turns.push({ role: 'assistant', content: m.content });
+    });
+    return turns;
+}
+export class Brain {
+    generating = new Map();
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Modèle utilisé : celui des réglages s'il est installé, sinon « promethee », sinon le premier. */
+    pickModel(installed) {
+        const wanted = this.deps.settings().model;
+        return installed.find((m) => m.name === wanted) ?? installed.find((m) => m.name.startsWith('promethee')) ?? installed[0] ?? null;
+    }
+    async models() {
+        const provider = this.deps.provider();
+        const [installed, loaded] = await Promise.all([provider.listModels(), provider.loadedModels().catch(() => [])]);
+        return { installed, loaded, selected: this.pickModel(installed)?.name ?? null };
+    }
+    stop(conversationId) {
+        const controller = this.generating.get(conversationId);
+        controller?.abort();
+        return controller !== undefined;
+    }
+    begin(conversationId) {
+        if (this.generating.has(conversationId))
+            throw new AppError('busy', 409, 'Une réponse est déjà en cours dans cette conversation.');
+        const controller = new AbortController();
+        this.generating.set(conversationId, controller);
+        return controller;
+    }
+    async classify(conversation) {
+        const recent = conversation.messages.slice(-4).map((m) => ({ role: m.role, content: m.content.slice(0, 600) || (m.proposal ? `(commande proposée : ${m.proposal.command})` : '') }));
+        try {
+            const out = await this.deps.provider().structured({ model: conversation.model, messages: [{ role: 'system', content: ROUTER_SYSTEM }, ...recent], schema: ROUTER_SCHEMA, timeoutMs: 20_000 });
+            return out.type === 'explication' ? 'explication' : 'action';
+        }
+        catch {
+            return 'action';
+        }
+    }
+    /**
+     * Faut-il chercher sur internet avant de répondre ? Un appel à part, mesuré seul (.equipe/recherche/mesure-routeur.md).
+     * En cas de doute ou d'erreur : pas de recherche, le tour se passe comme avant.
+     */
+    async searchPlan(conversation) {
+        const messages = conversation.messages;
+        let last = '';
+        let previousAnswer = null;
+        let previousRequest = null;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            if (!m)
+                continue;
+            if (m.role === 'user' && !last)
+                last = m.content;
+            else if (last && m.role === 'assistant' && m.content && previousAnswer === null)
+                previousAnswer = m.content;
+            else if (previousAnswer !== null && m.role === 'user') {
+                previousRequest = m.content;
+                break;
+            }
+        }
+        if (!last)
+            return null;
+        try {
+            const out = (await this.deps.provider().structured({
+                model: conversation.model,
+                messages: [
+                    { role: 'system', content: SEARCH_ROUTER_SYSTEM },
+                    { role: 'user', content: searchRouterInput(last, previousAnswer, previousRequest) },
+                ],
+                schema: SEARCH_ROUTER_SCHEMA,
+                timeoutMs: 20_000,
+                maxTokens: 120,
+            }));
+            // Sans requête, le classement n'est pas sûr (« affiche la date du jour » sortait ainsi) : pas de recherche
+            const query = typeof out?.requete === 'string' ? out.requete.trim() : '';
+            if (out?.chercher !== true || !query)
+                return null;
+            const place = typeof out.lieu === 'string' && out.lieu.trim() ? cut(out.lieu.trim(), 120) : null;
+            return { query: cut(query.replace(/\s+/g, ' '), 200), place };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** La recherche elle-même : un message sans texte qui porte la requête, les sources et le lieu. */
+    async *search(conversation, model, plan, signal) {
+        const { journal, store } = this.deps;
+        const running = { query: plan.query, state: 'running', sources: [], placeQuery: plan.place, place: null, error: null, durationMs: null };
+        const message = { id: id16(), role: 'assistant', content: '', at: new Date().toISOString(), model: model.name, search: running };
+        conversation.messages.push(message);
+        store.save(conversation);
+        yield { type: 'message', message: { ...message } };
+        const started = performance.now();
+        const backend = this.deps.search();
+        const asked = [...conversation.messages].reverse().find((m) => m.role === 'user')?.content ?? '';
+        const many = detectMany(asked, plan.query);
+        const findMap = async () => {
+            if (many) {
+                // Plusieurs lieux (« tous les hôtels de Paris ») : la zone par Photon, puis les points à part, sans les attendre
+                // (Overpass met de 2 à 40 s selon sa charge). Les notes ne s'affichent que si le classement voulait une carte.
+                for (const candidate of anchorCandidates(plan.query, plan.place, many)) {
+                    const anchor = await backend.place(candidate, signal);
+                    if (!anchor || !anchorAccepted(candidate, anchor))
+                        continue;
+                    const where = zoneOf(anchor);
+                    if (!where)
+                        return { place: null, places: null, note: plan.place ? `La zone « ${anchor.name} » est trop grande pour y lister des ${many.label}. Précise une ville ou un quartier.` : null };
+                    this.deps.prefetchPlaces?.(many, where);
+                    const around = where.kind === 'around';
+                    return { place: null, places: { label: many.label, zone: anchor.name, mode: around ? 'around' : 'area', radius: around ? where.radius : null, request: { category: many.label, where } }, note: null };
+                }
+                return { place: null, places: null, note: plan.place ? `Zone introuvable sur la carte : « ${plan.place} ».` : null };
+            }
+            // Le lieu : la requête d'abord, plus précise que « lieu » qui se réduit souvent à la ville (mesure-lieux.ts : 8 lieux
+            // justes sur 12 au lieu de 6), puis « lieu ». L'un après l'autre, en même temps que la recherche générale.
+            for (const candidate of plan.place ? placeCandidates(plan.query, plan.place) : []) {
+                const found = await backend.place(candidate, signal);
+                if (found)
+                    return { place: found, places: null, note: null };
+            }
+            return { place: null, places: null, note: null };
+        };
+        const [web, map] = await Promise.allSettled([backend.web(plan.query, signal), findMap()]);
+        const durationMs = Math.round(performance.now() - started);
+        const found = map.status === 'fulfilled' ? map.value : { place: null, places: null, note: null };
+        // Plusieurs lieux : pas de « lieu introuvable », la carte (ou sa note) le remplace
+        const shown = { place: found.place, placeQuery: many ? null : plan.place, places: found.places, placesNote: found.note };
+        const search = web.status === 'fulfilled'
+            ? { ...running, ...shown, state: 'done', sources: web.value, durationMs }
+            : { ...running, ...shown, state: 'failed', error: signal.aborted ? 'Recherche interrompue.' : describeError(web.reason).message, durationMs };
+        message.search = search;
+        store.save(conversation);
+        const onMap = search.place ? `, lieu : ${search.place.name}` : search.places ? `, carte : ${search.places.label} (${search.places.zone})` : '';
+        const detail = search.state === 'done' ? `${search.sources.length} source${search.sources.length > 1 ? 's' : ''}${onMap}` : (search.error ?? undefined);
+        journal.add({
+            kind: 'search',
+            outcome: search.state === 'done' ? 'ok' : signal.aborted ? 'cancelled' : 'error',
+            title: `Recherche web : ${cut(plan.query, 100)}`,
+            detail,
+            data: {
+                query: plan.query,
+                place: search.place?.name ?? (search.places ? null : plan.place),
+                ...(search.places ? { places: { label: search.places.label, zone: search.places.zone } } : {}),
+                sources: search.sources.map((s) => s.url),
+                conversation: conversation.id,
+                origin: 'console',
+            },
+        });
+        yield { type: 'search', messageId: message.id, search };
+        if (search.state !== 'done' || signal.aborted || !this.deps.settings().search.learn)
+            return search;
+        return yield* this.learn(conversation, message, search, asked, signal);
+    }
+    /**
+     * Après la recherche : lit en entier les meilleures pages, les retient dans le savoir local, puis choisit les passages que
+     * le modèle relira, de ces pages et des pages retenues lors de recherches précédentes. Les pages se lisent ensemble, 15 s
+     * au plus. Une page lue il y a moins de 7 jours n'est pas relue.
+     */
+    async *learn(conversation, message, search, asked, signal) {
+        const { savoir, readPage, journal, store } = this.deps;
+        if (!savoir || !readPage)
+            return search;
+        const ids = new Map();
+        const pages = pagesToRead(search.sources).map((s) => {
+            const known = savoir.fresh(s.url);
+            if (!known)
+                return { n: s.n, url: s.url, state: 'reading', title: null, chars: 0, error: null };
+            ids.set(s.n, known.id);
+            return { n: s.n, url: s.url, state: 'known', title: known.title, chars: known.chars, error: null };
+        });
+        const show = () => ({ ...search, pages: pages.map((p) => ({ ...p })) });
+        const budget = AbortSignal.any([signal, AbortSignal.timeout(READ_BUDGET_MS)]);
+        const readOne = async (i) => {
+            const page = pages[i];
+            try {
+                const text = await readPage(page.url, budget);
+                const kept = savoir.learn({ url: page.url, title: text.title, lang: text.lang, text: text.text, query: search.query });
+                ids.set(page.n, kept.id);
+                pages[i] = { ...page, state: 'learned', title: kept.title, chars: kept.chars };
+            }
+            catch (err) {
+                const why = signal.aborted ? 'Lecture interrompue.' : budget.aborted ? `Pas lue dans les ${READ_BUDGET_MS / 1000} s.` : err instanceof Error ? err.message : String(err);
+                pages[i] = { ...page, state: 'failed', error: why };
+            }
+            return i;
+        };
+        const pending = new Map();
+        pages.forEach((p, i) => {
+            if (p.state === 'reading')
+                pending.set(i, readOne(i));
+        });
+        if (pending.size > 0) {
+            message.search = show();
+            yield { type: 'search', messageId: message.id, search: message.search };
+        }
+        while (pending.size > 0) {
+            pending.delete(await Promise.race(pending.values()));
+            message.search = show();
+            yield { type: 'search', messageId: message.id, search: message.search };
+        }
+        const read = pages.flatMap((p) => {
+            const pageId = ids.get(p.n);
+            return pageId && (p.state === 'learned' || p.state === 'known') ? [{ n: p.n, pageId, fresh: p.state === 'learned' }] : [];
+        });
+        const next = Math.max(0, ...search.sources.map((s) => s.n)) + 1;
+        let extracts = [];
+        let failure = null;
+        try {
+            extracts = signal.aborted ? [] : searchExtracts(savoir, read, `${search.query} ${asked}`, search.query, next);
+        }
+        catch (err) {
+            // Base illisible : la réponse se fait avec la liste des résultats seule, et le journal le dit
+            failure = describeError(err).message;
+        }
+        const done = { ...search, pages: pages.map((p) => ({ ...p })), extracts };
+        message.search = done;
+        store.save(conversation);
+        if (pages.length > 0 || (extracts?.length ?? 0) > 0 || failure) {
+            const count = (state) => pages.filter((p) => p.state === state).length;
+            const [learned, known, failed] = [count('learned'), count('known'), count('failed')];
+            const parts = [
+                learned ? plural(learned, 'page retenue', 'pages retenues') : '',
+                known ? `${known} déjà dans le savoir` : '',
+                failed ? plural(failed, 'non lue', 'non lues') : '',
+            ].filter(Boolean);
+            journal.add({
+                kind: 'search',
+                outcome: failure ? 'error' : signal.aborted ? 'cancelled' : learned + known > 0 || pages.length === 0 ? 'ok' : 'error',
+                title: `Pages lues : ${cut(search.query, 100)}`,
+                detail: failure ?? `${parts.join(', ') || 'aucune page lisible parmi les résultats'}. ${plural(extracts?.length ?? 0, 'passage donné', 'passages donnés')} au modèle.`,
+                data: {
+                    query: search.query,
+                    // sources : les adresses des pages, que le journal affiche comme pour une recherche ; pages : le détail
+                    sources: pages.map((p) => p.url),
+                    pages: pages.map((p) => ({ url: p.url, state: p.state, chars: p.chars, ...(p.error ? { error: p.error } : {}) })),
+                    extracts: (extracts ?? []).map((e) => ({ n: e.n, url: e.url, fresh: e.fresh })),
+                    conversation: conversation.id,
+                    origin: 'console',
+                },
+            });
+        }
+        yield { type: 'search', messageId: message.id, search: done };
+        return done;
+    }
+    /**
+     * Sans recherche web, pour une explication : les passages du savoir local qui collent à la question, s'il y en a. Ils
+     * forment un message sans texte, comme une recherche, et la réponse qui suit se fait sans l'outil de commande.
+     */
+    *recall(conversation, model, question) {
+        const { savoir, settings, store, journal } = this.deps;
+        if (!savoir || !settings().search.learn)
+            return null;
+        let recall;
+        try {
+            recall = { query: question.slice(0, 500), extracts: recallExtracts(savoir, question) };
+        }
+        catch {
+            return null;
+        }
+        if (recall.extracts.length === 0)
+            return null;
+        const message = { id: id16(), role: 'assistant', content: '', at: new Date().toISOString(), model: model.name, recall };
+        conversation.messages.push(message);
+        store.save(conversation);
+        const urls = [...new Set(recall.extracts.map((e) => e.url))];
+        journal.add({
+            kind: 'ai',
+            outcome: 'ok',
+            title: `Savoir local relu : ${plural(urls.length, 'page', 'pages')}`,
+            detail: [...new Set(recall.extracts.map((e) => e.title))].map((t) => cut(t, 80)).join(' · '),
+            data: { conversation: conversation.id, pages: urls, extracts: recall.extracts.length },
+        });
+        yield { type: 'message', message: { ...message } };
+        yield { type: 'recall', messageId: message.id, recall };
+        return recall;
+    }
+    /** Envoie un message de l'utilisateur. attachments : de longs textes collés, rangés à part (comme des fichiers joints). */
+    async send(conversationId, text, attachments = []) {
+        const { store, provider } = this.deps;
+        const conversation = store.get(conversationId);
+        const installed = await provider().listModels();
+        const model = this.pickModel(installed);
+        if (!model)
+            throw new AppError('model_missing', 404, 'Aucun modèle n’est installé dans Ollama. Installe-en un avec « ollama pull » ou « ollama create ».');
+        const controller = this.begin(conversationId);
+        for (const m of conversation.messages)
+            if (m.proposal?.status === 'pending' || m.proposal?.status === 'running')
+                m.proposal = { ...m.proposal, status: 'expired', ticket: null };
+        conversation.model = model.name;
+        const user = { id: id16(), role: 'user', content: text, at: new Date().toISOString(), ...(attachments.length > 0 ? { attachments } : {}) };
+        conversation.messages.push(user);
+        // Titre : le texte tapé, sinon le nom de la première pièce jointe, sinon le début de son contenu
+        if (conversation.messages.length === 1) {
+            const titre = text.trim() || attachments[0]?.name || attachments[0]?.text || '';
+            conversation.title = titre.replace(/\s+/g, ' ').slice(0, 64);
+        }
+        store.save(conversation);
+        const self = this;
+        return (async function* () {
+            try {
+                yield { type: 'message', message: user };
+                // L'un après l'autre, comme pendant la mesure : lancés ensemble, Ollama les calcule en lot et le classement de la
+                // recherche change (65/68 au lieu de 66/68, lieux moins précis) pour presque rien de gagné (0,68 s contre 0,76 s).
+                const plan = self.deps.settings().search.enabled ? await self.searchPlan(conversation) : null;
+                if (plan) {
+                    const search = yield* self.search(conversation, model, plan, controller.signal);
+                    if (!controller.signal.aborted)
+                        yield* self.generate(conversation, model, 'search', controller.signal, { search });
+                }
+                else {
+                    const mode = model.capabilities.includes('tools') ? await self.classify(conversation) : 'explication';
+                    const reglages = self.deps.settings();
+                    const auto = mode === 'action' && reglages.fullCyber && reglages.autoRun;
+                    if (auto)
+                        self.deps.journal.add({ kind: 'ai', outcome: 'info', title: `Mode auto lancé : ${text.replace(/\s+/g, ' ').slice(0, 100)}`, detail: `Jusqu'à ${MAX_AUTO_STEPS} commandes autorisées enchaînées. Les garde-fous (destructrices, interdites, hors périmètre) tiennent.`, data: { conversation: conversation.id, origin: 'console' } });
+                    // Pour une explication seulement : une demande d'action garde son outil, sans texte venu d'internet à côté
+                    const recall = mode === 'explication' ? yield* self.recall(conversation, model, text) : null;
+                    yield* self.generate(conversation, model, mode, controller.signal, recall ? { recall } : { auto });
+                }
+                yield { type: 'done' };
+            }
+            finally {
+                self.generating.delete(conversationId);
+            }
+        })();
+    }
+    /** Décision de l'utilisateur sur une proposition : exécuter ou refuser, puis laisser le modèle conclure. */
+    async decide(conversationId, proposalId, decision, acknowledge) {
+        const { store, engine, journal, provider } = this.deps;
+        const conversation = store.get(conversationId);
+        const message = conversation.messages.find((m) => m.proposal?.id === proposalId);
+        const proposal = message?.proposal;
+        if (!message || !proposal || proposal.status !== 'pending')
+            throw badRequest('Cette proposition n’attend plus de décision.', 'not_pending');
+        const installed = await provider().listModels();
+        const model = installed.find((m) => m.name === conversation.model) ?? this.pickModel(installed);
+        if (!model)
+            throw new AppError('model_missing', 404, 'Le modèle de cette conversation n’est plus installé.');
+        let execution = null;
+        if (decision === 'approve') {
+            try {
+                execution = engine.start(proposal.ticket ?? '', { acknowledge, confirmation: 'human' });
+            }
+            catch (err) {
+                if (err instanceof AppError && err.code === 'ticket_expired') {
+                    message.proposal = { ...proposal, status: 'expired', ticket: null };
+                    store.save(conversation);
+                }
+                throw err;
+            }
+        }
+        let controller;
+        try {
+            controller = this.begin(conversationId);
+        }
+        catch (err) {
+            if (execution)
+                engine.cancel(execution.execId);
+            throw err;
+        }
+        const self = this;
+        return (async function* () {
+            try {
+                if (!execution) {
+                    message.proposal = { ...proposal, status: 'denied', ticket: null };
+                    journal.add({ kind: 'ai', outcome: 'refused', title: `Proposition écartée par toi : ${proposal.command.slice(0, 100)}`, data: { conversation: conversationId, command: proposal.command } });
+                    store.save(conversation);
+                    yield { type: 'proposal', messageId: message.id, proposal: message.proposal };
+                }
+                else {
+                    yield* self.runExecution(conversation, message, proposal, execution, controller.signal);
+                }
+                if (!controller.signal.aborted)
+                    yield* self.generate(conversation, model, 'action', controller.signal);
+                yield { type: 'done' };
+            }
+            finally {
+                self.generating.delete(conversationId);
+            }
+        })();
+    }
+    /** Lance une commande déjà démarrée, en relaie la sortie, et rend la proposition terminée (done ou failed). Partagé par la décision humaine et le mode auto. */
+    async *runExecution(conversation, message, proposal, execution, signal) {
+        const { engine, store } = this.deps;
+        const onAbort = () => void engine.cancel(execution.execId);
+        signal.addEventListener('abort', onAbort, { once: true });
+        const running = { ...proposal, status: 'running', ticket: null };
+        message.proposal = running;
+        yield { type: 'proposal', messageId: message.id, proposal: running };
+        let output = '';
+        let done = { ...running, status: 'failed', result: { exitCode: null, durationMs: 0, cancelled: true, timedOut: false, truncated: false, output: '' } };
+        try {
+            for await (const event of execution.events) {
+                yield { type: 'exec', proposalId: proposal.id, event };
+                if (event.type === 'out')
+                    output = (output + event.text).slice(-60_000);
+                else if (event.type === 'end')
+                    done = {
+                        ...running,
+                        status: event.exitCode === 0 ? 'done' : 'failed',
+                        result: { exitCode: event.exitCode, durationMs: event.durationMs, cancelled: event.cancelled, timedOut: event.timedOut, truncated: event.truncated, output },
+                    };
+            }
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+            message.proposal = done;
+            store.save(conversation);
+        }
+        yield { type: 'proposal', messageId: message.id, proposal: done };
+        return done;
+    }
+    /**
+     * Réponse du modèle. Après une recherche ou un rappel du savoir, l'outil de commande n'est pas proposé : un texte venu
+     * d'internet ne doit pas pouvoir pousser le modèle à proposer une commande dans ce tour.
+     */
+    async *generate(conversation, model, mode, signal, context = {}) {
+        const { provider, engine, journal, settings, store } = this.deps;
+        const withTools = mode === 'action' && !context.search && !context.recall && model.capabilities.includes('tools') && engine.available;
+        const cwd = engine.defaultCwd();
+        const fullCyber = settings().fullCyber;
+        const auto = context.auto === true && withTools;
+        const system = context.search
+            ? `${systemPrompt(cwd, false, fullCyber)}\n\n${searchAnswerRules(context.search)}`
+            : context.recall
+                ? `${systemPrompt(cwd, false, fullCyber)}\n\n${recallRules()}`
+                : `${systemPrompt(cwd, withTools, fullCyber)}${auto ? `\n\n${autoRunRules(MAX_AUTO_STEPS)}` : ''}`;
+        let refusals = 0;
+        let autoSteps = 0;
+        for (;;) {
+            // Mode auto : au bout de la limite, on s'arrête net et on le dit, sans laisser le modèle enchaîner sans fin.
+            if (auto && autoSteps >= MAX_AUTO_STEPS) {
+                const note = { id: id16(), role: 'assistant', content: `J'ai exécuté ${autoSteps} commandes sans conclure. Je m'arrête par sécurité. Relance-moi si tu veux que je continue.`, at: new Date().toISOString(), model: model.name };
+                conversation.messages.push(note);
+                store.save(conversation);
+                yield { type: 'message', message: { ...note } };
+                return;
+            }
+            const message = { id: id16(), role: 'assistant', content: '', at: new Date().toISOString(), model: model.name };
+            conversation.messages.push(message);
+            yield { type: 'message', message: { ...message } };
+            let call = null;
+            try {
+                const turns = toTurns({ ...conversation, messages: conversation.messages.slice(0, -1) });
+                const chunks = provider().chat({
+                    model: model.name,
+                    messages: [{ role: 'system', content: system }, ...turns],
+                    ...(withTools ? { tools: [COMMAND_TOOL] } : {}),
+                    signal,
+                    firstTokenTimeoutMs: settings().ollama.replyTimeoutSec * 1000,
+                    idleTimeoutMs: 60_000,
+                    disableThinking: model.capabilities.includes('thinking'),
+                });
+                for await (const chunk of chunks) {
+                    if (chunk.type === 'token') {
+                        message.content += chunk.text;
+                        yield { type: 'token', messageId: message.id, text: chunk.text };
+                    }
+                    else if (chunk.type === 'tool') {
+                        if (!call && chunk.call.name === TOOL_NAME)
+                            call = chunk.call;
+                    }
+                    else {
+                        message.stats = chunk.stats;
+                        yield { type: 'stats', messageId: message.id, stats: chunk.stats };
+                    }
+                }
+            }
+            catch (err) {
+                const { code, message: text } = describeError(err);
+                message.error = text;
+                store.save(conversation);
+                journal.add({ kind: 'ai', outcome: code === 'aborted' ? 'cancelled' : 'error', title: `Réponse de ${model.name} interrompue`, detail: text, data: { conversation: conversation.id, model: model.name, code } });
+                yield { type: 'message', message: { ...message } };
+                if (code !== 'aborted')
+                    yield { type: 'error', code, message: text };
+                return;
+            }
+            journal.add({
+                kind: 'ai',
+                outcome: 'ok',
+                title: `Réponse de ${model.name}`,
+                detail: message.stats ? `${message.stats.tokens} tokens à ${message.stats.tokensPerSec} tokens/s.` : undefined,
+                data: { conversation: conversation.id, model: model.name, tokens: message.stats?.tokens ?? 0, tokensPerSec: message.stats?.tokensPerSec ?? 0, totalMs: message.stats?.totalMs ?? 0, proposed: call !== null },
+            });
+            if (!call) {
+                const outputs = conversation.messages.flatMap((m) => (m.proposal?.result ? [m.proposal.result.output, m.proposal.command] : []));
+                if (outputs.length > 0) {
+                    // Les résultats de recherche et les passages lus comptent aussi comme source : un prix lu sur le web n'est pas inventé
+                    const found = conversation.messages.flatMap((m) => [...(m.search ? [searchResultText(m.search, true)] : []), ...(m.recall ? [extractsText(m.recall.extracts, 0)] : [])]);
+                    const references = [...outputs, ...found, ...conversation.messages.filter((m) => m.role === 'user').map((m) => userText(m))].join('\n');
+                    const missing = unverifiedValues(message.content, references);
+                    if (missing.length > 0)
+                        message.unverified = missing.slice(0, 12);
+                }
+                store.save(conversation);
+                yield { type: 'message', message: { ...message } };
+                return;
+            }
+            const command = typeof call.arguments.commande === 'string' ? call.arguments.commande.trim() : '';
+            const explanation = typeof call.arguments.explication === 'string' ? call.arguments.explication.trim() : '';
+            if (!command) {
+                message.error = 'Le modèle a appelé l’outil sans donner de commande.';
+                store.save(conversation);
+                yield { type: 'message', message: { ...message } };
+                return;
+            }
+            let proposal;
+            try {
+                const preview = await engine.preview(command, cwd, 'ai');
+                proposal = { id: id16(), command: preview.command, explanation, verdict: preview.verdict, status: preview.ticket ? 'pending' : 'refused', ticket: preview.ticket };
+            }
+            catch (err) {
+                const { code, message: text } = describeError(err);
+                const verdict = { level: 'denied', reasons: [{ code, message: text, severity: 'block' }], commands: [], writes: [], network: [] };
+                proposal = { id: id16(), command, explanation, verdict, status: 'refused', ticket: null };
+            }
+            message.proposal = proposal;
+            store.save(conversation);
+            // En mode auto, on n'affiche pas l'état « en attente » (aucun bouton à présenter) : l'exécution part tout de suite.
+            if (!(auto && proposal.status === 'pending'))
+                yield { type: 'proposal', messageId: message.id, proposal };
+            if (proposal.status === 'pending') {
+                // Hors auto : on s'arrête et on attend la décision humaine.
+                if (!auto)
+                    return;
+                // Mode auto : la politique a délivré un ticket (lecture ou sensible), on exécute nous-mêmes, comme un « oui ».
+                let execution;
+                try {
+                    execution = engine.start(proposal.ticket ?? '', { acknowledge: true, confirmation: 'human' });
+                }
+                catch (err) {
+                    const { code, message: text } = describeError(err);
+                    message.proposal = { ...proposal, status: 'refused', ticket: null, verdict: { ...proposal.verdict, reasons: [{ code, message: text, severity: 'block' }] } };
+                    store.save(conversation);
+                    yield { type: 'proposal', messageId: message.id, proposal: message.proposal };
+                    return;
+                }
+                yield* this.runExecution(conversation, message, proposal, execution, signal);
+                autoSteps++;
+                if (signal.aborted)
+                    return;
+                continue;
+            }
+            // Refusée par la politique : le modèle reçoit la raison et peut corriger, trois fois au plus.
+            refusals++;
+            if (refusals >= MAX_REFUSALS || signal.aborted)
+                return;
+        }
+    }
+}