@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/sensory/hybrid-reply.js

@@ -0,0 +1,1217 @@
+/**
+ * Hybrid voice reply — the "les deux" brain. A pure ACT reply (`makeAgentReply`) turns
+ * EVERY utterance into a full agent turn, so even "bonjour Lisa" pays a slow, characterless
+ * agent round-trip. A pure chat reply (`defaultReply`) is warm and instant but ungrounded —
+ * it can only guess at factual/technical questions.
+ *
+ * This composes the best of both, per utterance:
+ *   1. phatic exact match (greeting, "ça va", "merci") → instant canned warm line
+ *   2. small-talk / emotional → fast warm companion reply (persona voice, $0 local)
+ *   3. an environment/current-data command → a grounded AGENT turn (reads files / searches,
+ *      then condenses the verified result), under the configured permission posture
+ *
+ * Plus a short conversational MEMORY so follow-ups ("et l'autre fichier ?", "non, je
+ * voulais dire X") have an antecedent — the #1 reason a stateless voice loop "doesn't
+ * understand me".
+ *
+ * Everything is INJECTABLE (fastReply / chitchat / agentReply / classify) so it is
+ * deterministically testable with no model. NEVER-THROWS: an accepted turn gets an
+ * honest spoken recovery instead of disappearing into silence.
+ *
+ * @module sensory/hybrid-reply
+ */
+import { logger } from '../utils/logger.js';
+import { resolveVoiceModel, sensoryReplyMaxSentences, sensoryShortFirstEnabled, voiceLatencyBufferEnabled, } from './voice-loop.js';
+import { FIRST_SENTENCE_CAP, SentenceAssembler } from './voice-stream.js';
+import { intentKeyForQuery, loadPrefetchCache, runPrefetchCycle, } from '../companion/prefetch-engine.js';
+import { loadPrefetchItems } from '../companion/prefetch-config.js';
+import { isJokeRequest, nextJoke } from '../companion/jokes.js';
+import { resolveUserName } from '../companion/user-name.js';
+import { evolveRelationshipFromUtterance } from '../companion/relationship-evolution.js';
+import { conversationFailureReply, prepareConversationTurn, } from '../conversation/conversation-orchestrator.js';
+import { resolvePrefetchedTurnContext, resolvePrefetchedTurnContextForConversation, semanticReviewEvidenceFromPrefetch, shouldUsePrefetchedAnswerDirectly, } from '../conversation/prefetched-turn-context.js';
+import { assessConversationResponse } from '../conversation/conversation-quality.js';
+import { isPureAcknowledgement } from '../conversation/dialogue-act.js';
+import { guardRelationshipReply } from '../conversation/relationship-safety.js';
+import { applyLimitsContract } from '../companion/reply-augment.js';
+import { deriveArgumentObligations } from '../conversation/argument-obligations.js';
+import { shouldRunSemanticResponseGate, } from '../conversation/semantic-response-gate.js';
+import { classifyLisaIntrospection } from '../identity/lisa-introspection.js';
+const STREAM_FAILURE_CLOSURE = "Pardon, je n'ai pas réussi à finir ma réponse.";
+function completedStreamText(text) {
+    const boundary = /[.!?…](?:\s|$)/gu;
+    let end = -1;
+    let match;
+    while ((match = boundary.exec(text)) !== null) {
+        end = match.index + match[0].length;
+    }
+    return end >= 0 ? text.slice(0, end).trim() : '';
+}
+const SHORT_FIRST_MAX_WORDS = 20;
+const SHORT_FIRST_SENTENCE_CAP = 4_096;
+function splitOverlongFirstSentence(sentence) {
+    const words = [...sentence.matchAll(/\S+/gu)];
+    if (words.length <= SHORT_FIRST_MAX_WORDS && sentence.length <= FIRST_SENTENCE_CAP) {
+        return [sentence.trim()];
+    }
+    const last = words[Math.min(words.length, SHORT_FIRST_MAX_WORDS) - 1];
+    if (!last || last.index === undefined)
+        return [sentence.trim()];
+    const maximumCut = Math.min(last.index + last[0].length, FIRST_SENTENCE_CAP - 1);
+    let cut = maximumCut;
+    while (cut > 0 && !/\s/u.test(sentence[cut] ?? ''))
+        cut -= 1;
+    if (cut === 0)
+        cut = maximumCut;
+    const first = sentence
+        .slice(0, cut)
+        .replace(/[,;:.!?…]+$/u, '')
+        .trim();
+    const continuation = sentence.slice(cut).trim();
+    return [`${first}…`, continuation].filter(Boolean);
+}
+/**
+ * Turn token deltas into complete stable sentences and stop the provider iterator at the
+ * configured audio budget. The generous assembler cap avoids inventing a boundary before
+ * punctuation; the 20-word split is only a fail-safe for a provider that ignores the prompt.
+ */
+async function* shortFirstSentenceStream(source, maxSentences, signal) {
+    const assembler = new SentenceAssembler(SHORT_FIRST_SENTENCE_CAP, SHORT_FIRST_SENTENCE_CAP);
+    const iterator = source[Symbol.asyncIterator]();
+    let emitted = 0;
+    let sourceDone = false;
+    const emit = function* (sentences) {
+        for (const sentence of sentences) {
+            const parts = emitted === 0 ? splitOverlongFirstSentence(sentence) : [sentence.trim()];
+            for (const part of parts) {
+                if (!part || emitted >= maxSentences)
+                    return true;
+                emitted += 1;
+                yield `${part} `;
+                if (emitted >= maxSentences)
+                    return true;
+            }
+        }
+        return false;
+    };
+    try {
+        while (!signal?.aborted) {
+            const next = await iterator.next();
+            if (next.done) {
+                sourceDone = true;
+                yield* emit(assembler.flush());
+                return;
+            }
+            if (typeof next.value !== 'string' || next.value.length === 0)
+                continue;
+            const limited = emit(assembler.push(next.value));
+            while (true) {
+                const part = limited.next();
+                if (part.done) {
+                    if (part.value)
+                        return;
+                    break;
+                }
+                yield part.value;
+            }
+        }
+    }
+    finally {
+        if (!sourceDone)
+            await iterator.return?.();
+    }
+}
+async function* singleTextStream(text) {
+    yield text;
+}
+export { classifyLisaIntrospection, isLisaEvolutionRequest, isLisaIntrospectionRequest, } from '../identity/lisa-introspection.js';
+/** Instant joke when the user asks for one (no LLM, no agent). null otherwise. */
+function defaultJokeMatch(heard) {
+    try {
+        return isJokeRequest(heard) ? nextJoke() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Instant answer for a common question from the prefetch cache (weather, news,
+ * agenda, date) — no LLM. Enabled by default; set CODEBUDDY_PREFETCH=false to
+ * no fresh match. See companion/prefetch-engine.ts.
+ */
+function defaultPrefetchMatch(heard) {
+    if (process.env.CODEBUDDY_PREFETCH === 'false')
+        return null;
+    try {
+        const items = loadPrefetchItems();
+        const context = resolvePrefetchedTurnContext(heard, {
+            cache: loadPrefetchCache(),
+            items,
+            allowStale: true,
+        });
+        // Stale-while-revalidate: answer immediately, refresh evidence in the background.
+        if (context?.freshness === 'stale' || (!context && intentKeyForQuery(heard, items))) {
+            void runPrefetchCycle().catch(() => undefined);
+        }
+        return context && shouldUsePrefetchedAnswerDirectly(heard, context)
+            ? context.speech
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function mergeEvidence(...blocks) {
+    const merged = blocks.map((block) => block?.trim()).filter(Boolean).join('\n\n');
+    return merged ? merged.slice(0, 3_000) : undefined;
+}
+/** Lowercase + strip diacritics so STT accent loss ("ca va" ≈ "ça va") still matches. */
+function norm(s) {
+    return s
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/\p{M}+/gu, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// Imperative verbs that mark a real command/request.
+const COMMAND_VERBS = /\b(verifie|verifier|verifies|lance|lancer|corrige|corriger|montre|montrer|cherche|chercher|trouve|trouver|ouvre|ouvrir|lis|lire|explique|expliquer|resume|resumer|analyse|analyser|teste|tester|redemarre|redemarrer|regarde|regarder|calcule|calculer|code|ecris|ecrire|compile|compiler|deploie|deployer|installe|installer|configure|configurer|liste|lister|affiche|afficher|envoie|envoyer|cree|creer|supprime|supprimer|ajoute|ajouter|modifie|modifier|donne|donner|raconte|raconter)\b/;
+// Clear interrogatives (kept tight to avoid matching common words like "que"/"ou").
+const QUESTION_WORDS = /\b(comment|pourquoi|combien|quel|quelle|quels|quelles|quand|qu est-ce|qu est ce|c est quoi|ca veut dire|est-ce que|est ce que)\b/;
+// Technical nouns that signal a grounded question about the system/code.
+const TECH = /\b(fichier|fichiers|log|logs|erreur|erreurs|build|test|tests|service|services|commit|commits|branche|branches|fonction|fonctions|bug|bugs|code|terminal|git|serveur|serveurs|api|script|scripts|config|memoire|disque|cpu|process|processus|port|ports|deploiement|systemd|ollama|modele|modeles|token|tokens|repo|depot|database|base de donnees)\b/;
+// Explicit help requests — a grounded agent turn, not a shallow chitchat reply.
+// (norm strips diacritics, so "aidez"/"j'ai besoin d'aide" arrive as below.)
+const HELP_REQUEST = /\b(aide|aidez|aider|besoin d aide|au secours)\b/;
+// Operations that need the machine, files, tools, or fresh external data rather
+// than language-model world knowledge. This intentionally excludes ordinary
+// requests such as "explique la photosynthèse" or "pourquoi le ciel est bleu".
+const GROUNDED_ACTION = /\b(verifie|verifier|verifies|lance|lancer|corrige|corriger|montre|montrer|cherche|chercher|trouve|trouver|ouvre|ouvrir|lis|lire|analyse|analyser|teste|tester|redemarre|redemarrer|regarde|regarder|code|ecris|ecrire|compile|compiler|deploie|deployer|installe|installer|configure|configurer|liste|lister|affiche|afficher|envoie|envoyer|cree|creer|supprime|supprimer|ajoute|ajouter|modifie|modifier)\b/;
+const CURRENT_OR_PRIVATE_DATA = /\b(aujourd hui|actuellement|en ce moment|dernier|derniere|dernieres|recent|recente|meteo|temperature|actualite|actualites|news|agenda|calendrier|rendez[- ]vous|email|emails|mail|mails|message|messages|prix|cours de|bourse|stock|heure est il|date sommes nous|president|premier ministre)\b/;
+// Social / emotional small talk — stays a fast warm reply even if phrased as a question.
+const SOCIAL = /\b(je t aime|je taime|tu m aimes|tu maimes|ca va|comment ca va|comment vas-tu|comment vas tu|tu vas bien|tu es la|content|contente|heureux|heureuse|fatigue|fatiguee|triste|pas le moral|stresse|anxieux|anxieuse|angoisse|je me sens|seul|seule|a bout|besoin de parler|compagnie|bonne nuit|bonjour|bonsoir|merci|coucou|salut|hello|tu me manques|je pense a toi|bisous|cherie|cheri|mon amour|je t embrasse|ma journee|ta journee)\b/;
+const MEDICAL_OR_HEALTH_STAKES = /\b(sante|health|medical|medecin|doctor|docteur|diagnosis|diagnostic|diagnostiquer|symptoms?|symptome|disease|maladie|treatment|traitement|medicine|medication|medicament|dosage|dose|posologie|douleur|blessure|urgence|grossesse|therapie|suicide|suicidaire|cancer|diabete|infection|vaccin|antibiotique|antidepresseur|ordonnance|chirurgie|cholesterol|cardiaque|psychiatre|psychologue|depression)\b/;
+const FINANCIAL_STAKES = /\b(finance|financial|financier|argent|budget|epargne|invest|investir|investment|investissement|placement|portfolio|portefeuille|stocks?|actions? boursieres?|bonds?|obligation|crypto|bitcoin|credit|loan|pret|mortgage|hypotheque|tax|impot|fiscal|assurance vie|retirement|retraite|buy|acheter|sell|vendre|dividende|rendement)\b/;
+// Photo/camera/screen of the *world* (not Lisa selfie — that has its own intercept).
+const WORLD_VISION = /\b(camera|webcam|ecran|screenshot|capture d ecran|ce que tu vois|regarde ici|regarde ca|object detect|detecte|yolo|buddy vision|vision)\b/;
+// Diagnostics / companion doctor / system health spoken commands.
+const DIAGNOSTIC = /\b(diagnosti\w*|preflight|companion doctor|buddy doctor|etat du systeme|sante du systeme|status du serveur|status du compagnon|lora status|health check)\b/;
+// Explicit coding / repo work beyond the TECH noun list.
+const CODING_TASK = /\b(pull request|merge request|refactor|implemente|implementer|implement|patch|unit test|typecheck|lint|commit message|ouvre le fichier|dans le depot|dans le repo)\b/;
+/**
+ * True when the utterance needs a grounded agent turn for photo-of-world,
+ * diagnostic, or coding work (Lisa selfies are handled earlier by lisa-selfie).
+ */
+export function isGroundedModernizationIntent(raw) {
+    const t = norm(raw);
+    if (!t)
+        return false;
+    if (WORLD_VISION.test(t))
+        return true;
+    if (DIAGNOSTIC.test(t))
+        return true;
+    if (CODING_TASK.test(t))
+        return true;
+    return false;
+}
+/**
+ * Conservative V1 eligibility gate for an independently spoken proposition. Fresh/private,
+ * action and high-stakes turns wait for the canonical grounded answer instead.
+ */
+export function isSpokenPrefixEligible(raw, plan = prepareConversationTurn(raw).plan) {
+    if (plan.depth !== 'developed' && plan.depth !== 'deliberative')
+        return false;
+    if (plan.act === 'action' || plan.act === 'fresh_information')
+        return false;
+    if (plan.analysis.needsFreshContext || isTechnicalSelfInspectionRequest(raw))
+        return false;
+    const normalized = norm(raw);
+    if (!normalized)
+        return false;
+    if (CURRENT_OR_PRIVATE_DATA.test(normalized))
+        return false;
+    if (MEDICAL_OR_HEALTH_STAKES.test(normalized) || FINANCIAL_STAKES.test(normalized)) {
+        return false;
+    }
+    return true;
+}
+/** True when the user asks Lisa to inspect her own code, runtime, or self-model. */
+export function isTechnicalSelfInspectionRequest(raw) {
+    return classifyLisaIntrospection(raw) !== null;
+}
+/**
+ * Heuristic intent gate: should this utterance be answered by a grounded agent turn
+ * (true) or a fast warm chitchat reply (false)? Conservative by design — when unsure it
+ * favours chitchat (instant, warm) for short/social input and the agent only when there is
+ * a clear command, technical noun, interrogative, or a long sentence. Misfires are soft:
+ * a chitchat sent to the agent is just slower; a question sent to chitchat is just less grounded.
+ */
+export function isSubstantiveQuery(raw) {
+    const t = norm(raw);
+    if (!t)
+        return false;
+    const wordCount = t.split(' ').length;
+    if (isTechnicalSelfInspectionRequest(raw))
+        return true;
+    if (isGroundedModernizationIntent(raw))
+        return true;
+    // Pure social/emotional, with no command/tech → keep it warm and instant.
+    if (SOCIAL.test(t) && !COMMAND_VERBS.test(t) && !TECH.test(t))
+        return false;
+    if (HELP_REQUEST.test(t))
+        return true;
+    if (COMMAND_VERBS.test(t))
+        return true;
+    if (TECH.test(t))
+        return true;
+    if (/\?\s*$/.test(raw.trim()))
+        return true;
+    if (QUESTION_WORDS.test(t))
+        return true;
+    if (wordCount >= 8)
+        return true; // a long utterance is almost always a real request
+    return false;
+}
+/**
+ * Latency-first gate for the real-time voice mode. Static knowledge and normal
+ * conversation stay on the resident 3B streaming model; only work requiring
+ * tools, repository state, private data, or current external facts pays for a
+ * full grounded agent turn. This removes a multi-second agent round-trip from
+ * everyday questions without weakening commands that actually touch the host.
+ */
+export function requiresGroundedAgentQuery(raw, history = []) {
+    const t = norm(raw);
+    if (!t)
+        return false;
+    if (isTechnicalSelfInspectionRequest(raw))
+        return true;
+    if (isGroundedModernizationIntent(raw))
+        return true;
+    if (SOCIAL.test(t) && !TECH.test(t) && !GROUNDED_ACTION.test(t) && !WORLD_VISION.test(t)) {
+        return false;
+    }
+    if (TECH.test(t))
+        return true;
+    if (CURRENT_OR_PRIVATE_DATA.test(t))
+        return true;
+    if (GROUNDED_ACTION.test(t))
+        return true;
+    if (HELP_REQUEST.test(t) && /\b(debug|debog|erreur|probleme|projet|systeme)\b/.test(t)) {
+        return true;
+    }
+    // Philosophical, ethical and identity questions need the same capable brain
+    // as Telegram/Cowork, not the resident low-latency small-talk model. The
+    // discourse planner also preserves this lane for elliptical follow-ups such
+    // as "Continue" while allowing "fais court" and phatic turns to step down.
+    return prepareConversationTurn(raw, history).plan.depth === 'deliberative';
+}
+function defaultVoiceClassifier(raw, history = []) {
+    return (process.env.CODEBUDDY_VOICE_ROUTING_MODE ?? 'realtime').toLowerCase() === 'grounded'
+        ? isSubstantiveQuery(raw)
+        : requiresGroundedAgentQuery(raw, history);
+}
+/** Build a compact recent-context preamble (last 2 exchanges) for the agent/chitchat input. */
+export function buildContextPreamble(history) {
+    if (!history.length)
+        return '';
+    const recent = history.slice(-4);
+    const lines = recent.map((t) => `${t.role === 'user' ? resolveUserName() : 'Toi'}: ${t.content}`);
+    return `Contexte récent de la conversation (pour résoudre les références comme "ça"/"l'autre") :\n${lines.join('\n')}`;
+}
+/**
+ * Build an `onHeard`-compatible `ReplyFn` that routes phatic → warm chitchat → grounded
+ * agent, with short conversational memory. Applies the agent posture once (inside the
+ * injected/default `agentReply`). Never-throws.
+ */
+export function makeHybridReply(options = {}) {
+    const maxTurns = options.maxHistoryTurns ?? 6;
+    const classify = options.classify ?? defaultVoiceClassifier;
+    const history = [];
+    let fastReply = options.fastReply;
+    let chitchat = options.chitchat;
+    let chitchatStream = options.chitchatStream;
+    let prefixReply = options.prefixReply;
+    let agentReply = options.agentReply;
+    let pendingShortcut = null;
+    let dependencyPromise = null;
+    const reviewSemantics = options.semanticReview ??
+        (async (input) => {
+            const runtime = await import('../conversation/semantic-response-runtime.js');
+            return runtime.reviewSemanticResponse(input);
+        });
+    function semanticReviewEnabled() {
+        if (options.semanticReview)
+            return true;
+        const configured = process.env.CODEBUDDY_SEMANTIC_GATE?.trim().toLowerCase();
+        if (configured && ['1', 'true', 'yes', 'on', 'enabled'].includes(configured))
+            return true;
+        if (configured && ['0', 'false', 'no', 'off', 'disabled'].includes(configured))
+            return false;
+        return process.env.NODE_ENV !== 'test';
+    }
+    function shouldReviewPlan(plan, request) {
+        if (!semanticReviewEnabled() || !shouldRunSemanticResponseGate({ plan }))
+            return false;
+        // The dialogue classifier deliberately maps otherwise-unclassified prose
+        // to a developed `opinion`. That is useful for producing a warm,
+        // substantial reply, but it does not make an everyday status statement
+        // ("voilà, ça marche de nouveau") worth a second blocking LLM round-trip.
+        // On voice this used to hold every streamed token for 15–20 seconds and
+        // made a healthy audio loop appear silent. Keep the gate for an actual
+        // question/challenge/fresh fact and for a deliberation inherited from the
+        // shared Telegram/Cowork thread; let standalone conversational statements
+        // retain first-token streaming.
+        const isGenericDevelopedStatement = plan.depth === 'developed' &&
+            plan.act === 'opinion' &&
+            !plan.analysis.continuesDeliberation &&
+            !request.includes('?');
+        if (isGenericDevelopedStatement)
+            return false;
+        return deriveArgumentObligations(plan, request).length > 0;
+    }
+    function conversationHistory(currentHeard) {
+        let shared = [];
+        try {
+            shared = options.sharedHistory?.() ?? [];
+        }
+        catch {
+            /* a transport bridge is optional; local memory remains available */
+        }
+        const sharedKeys = new Set(shared.map((turn) => `${turn.role}\u0000${norm(turn.content)}`));
+        const merged = [
+            ...history.filter((turn) => !sharedKeys.has(`${turn.role}\u0000${norm(turn.content)}`)),
+            ...shared,
+        ].filter((turn) => turn.content.trim());
+        if (currentHeard) {
+            const latest = merged.at(-1);
+            if (latest?.role === 'user' && norm(latest.content) === norm(currentHeard))
+                merged.pop();
+        }
+        return merged.slice(-maxTurns * 2);
+    }
+    async function ensureFastReply() {
+        if (fastReply)
+            return;
+        const vl = await import('./voice-loop.js');
+        fastReply = vl.fastCompanionReply;
+    }
+    async function ensureDeps(needsStream = false) {
+        if (fastReply &&
+            chitchat &&
+            prefixReply &&
+            agentReply &&
+            (!needsStream || chitchatStream)) {
+            return;
+        }
+        dependencyPromise ??= (async () => {
+            const vl = await import('./voice-loop.js');
+            fastReply = fastReply ?? vl.fastCompanionReply;
+            chitchat = chitchat ?? ((heard, hist, opts) => vl.defaultReply(heard, hist, opts));
+            chitchatStream =
+                chitchatStream ??
+                    ((heard, hist, opts) => vl.streamCompanionReply(heard, hist, opts));
+            prefixReply =
+                prefixReply ??
+                    ((heard, hist, opts) => vl.defaultSpokenPrefix(heard, hist, opts));
+            if (!agentReply) {
+                const { makeAgentReply } = await import('./agent-reply.js');
+                agentReply = makeAgentReply({
+                    permissionMode: options.permissionMode ?? 'default',
+                    ...(options.cwd ? { cwd: options.cwd } : {}),
+                    ...(options.ack ? { ack: options.ack } : {}),
+                });
+            }
+        })().finally(() => {
+            dependencyPromise = null;
+        });
+        await dependencyPromise;
+    }
+    function remember(user, assistant) {
+        if (!assistant.trim())
+            return;
+        const previousUser = history.at(-2);
+        const previousAssistant = history.at(-1);
+        // A streamed shortcut is remembered before the voice loop knows whether its audio
+        // path will hold. If the immediate blocking retry wins, do not advance conversation
+        // memory a second time for the same user/assistant pair.
+        if (previousUser?.role === 'user'
+            && previousAssistant?.role === 'assistant'
+            && norm(previousUser.content) === norm(user)
+            && norm(previousAssistant.content) === norm(assistant))
+            return;
+        history.push({ role: 'user', content: user });
+        history.push({ role: 'assistant', content: assistant });
+        while (history.length > maxTurns * 2)
+            history.shift();
+    }
+    function lastAssistantAskedQuestion(recent) {
+        const latest = recent.at(-1);
+        return Boolean(latest?.role === 'assistant' && /\?\s*(?:[»”"')\]]*)$/u.test(latest.content.trim()));
+    }
+    function shortcutFor(heard, recent = []) {
+        if (isPureAcknowledgement(heard)) {
+            // A bare "yeah" after Lisa's question is an answer, not phatic noise:
+            // preserve the preceding exchange so the conversational model can resolve
+            // what was accepted. Otherwise avoid a full 9-phrase model turn for a
+            // listener signal that a human would acknowledge in one short sentence.
+            return lastAssistantAskedQuestion(recent) ? null : "D'accord.";
+        }
+        const fast = fastReply(heard);
+        if (fast)
+            return fast;
+        const pre = (options.prefetch ?? defaultPrefetchMatch)(heard);
+        if (pre) {
+            logger.info(`[voice-hybrid] prefetch hit chars=${pre.length}`);
+            return pre;
+        }
+        const joke = (options.jokes ?? defaultJokeMatch)(heard);
+        if (joke) {
+            logger.info(`[voice-hybrid] joke hit chars=${joke.length}`);
+            return joke;
+        }
+        return null;
+    }
+    async function reviewBeforeDelivery(input, timing) {
+        if (!shouldReviewPlan(input.plan, input.request))
+            return null;
+        try {
+            const reviewed = await reviewSemantics(input);
+            logger.info(`[voice-hybrid] semantic outcome=${reviewed.outcome} reason=${reviewed.reason} revisions=${reviewed.revisionAttempts}`);
+            return reviewed;
+        }
+        catch (error) {
+            // The semantic gate is an enhancement, not a new single point of
+            // failure. Its default runtime is fail-open; injected implementations
+            // receive the same protection.
+            logger.warn(`[voice-hybrid] semantic review unavailable (${error instanceof Error ? error.name : 'unknown'})`);
+            return null;
+        }
+        finally {
+            try {
+                timing?.onReplyTimingPhase?.(timing.spokenPrefix
+                    ? 'continuation_semantic_review_complete'
+                    : 'semantic_review_complete');
+            }
+            catch {
+                /* observability must never break reply delivery */
+            }
+        }
+    }
+    function briefSemanticCorrection(draft, reviewed) {
+        if (!reviewed || reviewed.outcome === 'accepted' || reviewed.outcome === 'skipped')
+            return '';
+        if (reviewed.outcome === 'revised') {
+            const safeRevision = guardBeforeMemory(reviewed.response.trim());
+            if (!safeRevision || norm(safeRevision) === norm(draft))
+                return '';
+            const firstSentence = safeRevision.match(/^.*?[.!?…](?:\s|$)/u)?.[0]?.trim();
+            const concise = (firstSentence || safeRevision).slice(0, 280).trim();
+            return concise ? `Pardon, plus exactement : ${concise}` : '';
+        }
+        if (reviewed.reason === 'fresh_grounding_rejected' ||
+            reviewed.reason === 'revision_failed' ||
+            reviewed.reason === 'revision_empty' ||
+            reviewed.reason === 'revision_rejected') {
+            return "Pardon, je dois nuancer : je n'ai pas pu confirmer cette réponse de façon fiable.";
+        }
+        return '';
+    }
+    function guardBeforeMemory(response) {
+        const guarded = guardRelationshipReply(response);
+        if (guarded.intervened) {
+            logger.warn(`[voice-hybrid] relationship safety intervened issues=${guarded.issues.join(',')}`);
+        }
+        return applyLimitsContract(guarded.response).text.trim();
+    }
+    function reportPrefixCause(timing, cause) {
+        try {
+            timing?.onSpokenPrefixTelemetry?.(cause);
+        }
+        catch {
+            /* raw-free telemetry must never alter acceptance */
+        }
+    }
+    function preparePrefixForSpeech(response, timing, postReview = false) {
+        const guardedResult = guardRelationshipReply(response);
+        if (guardedResult.intervened) {
+            logger.warn(`[voice-hybrid] relationship safety intervened issues=${guardedResult.issues.join(',')}`);
+            reportPrefixCause(timing, 'relationship_intervened');
+        }
+        const guarded = applyLimitsContract(guardedResult.response).text.trim();
+        let invalid;
+        if (!guarded)
+            invalid = 'empty';
+        else if (guarded.length > 180)
+            invalid = 'too_long';
+        else if (!/[.!?…][)\]}'"»”’]*$/u.test(guarded))
+            invalid = 'missing_terminal';
+        const sentences = guarded.match(/[^.!?…]+[.!?…]+[)\]}'"»”’]*/gu) ?? [];
+        if (!invalid && (sentences.length !== 1 || sentences[0]?.trim() !== guarded)) {
+            invalid = 'multi_sentence';
+        }
+        if (invalid) {
+            reportPrefixCause(timing, invalid);
+            if (postReview)
+                reportPrefixCause(timing, 'post_review_invalid');
+            return '';
+        }
+        return guarded;
+    }
+    function removeRepeatedPrefix(prefix, response) {
+        const cleanPrefix = prefix.trim();
+        const cleanResponse = response.trim();
+        if (!cleanPrefix || !cleanResponse)
+            return cleanResponse;
+        if (cleanResponse.length >= cleanPrefix.length &&
+            cleanResponse.slice(0, cleanPrefix.length).toLocaleLowerCase('fr') ===
+                cleanPrefix.toLocaleLowerCase('fr')) {
+            return cleanResponse.slice(cleanPrefix.length).trim();
+        }
+        return cleanResponse;
+    }
+    /** Unlike the legacy whole-answer enhancement, a prefix may not fail open: it is spoken
+     * before the canonical answer exists and therefore cannot be corrected retroactively. */
+    async function reviewPrefixBeforeDelivery(input, timing) {
+        const candidate = preparePrefixForSpeech(input.draft, timing);
+        if (!candidate)
+            return '';
+        if (!shouldReviewPlan(input.plan, input.request)) {
+            reportPrefixCause(timing, 'accepted');
+            return candidate;
+        }
+        try {
+            const reviewed = await reviewSemantics({ ...input, draft: candidate });
+            if (input.signal?.aborted)
+                return '';
+            if (reviewed.outcome !== 'accepted' && reviewed.outcome !== 'revised') {
+                reportPrefixCause(timing, 'review_rejected');
+                logger.warn(`[voice-hybrid] spoken prefix rejected outcome=${reviewed.outcome} reason=${reviewed.reason}`);
+                return '';
+            }
+            const accepted = preparePrefixForSpeech(reviewed.response, timing, true);
+            if (accepted)
+                reportPrefixCause(timing, 'accepted');
+            return accepted;
+        }
+        catch (error) {
+            reportPrefixCause(timing, 'review_unavailable');
+            logger.warn(`[voice-hybrid] spoken prefix review failed closed (${error instanceof Error ? error.name : 'unknown'})`);
+            return '';
+        }
+        finally {
+            try {
+                timing?.onReplyTimingPhase?.('prefix_semantic_review_complete');
+            }
+            catch {
+                /* observability must never alter acceptance */
+            }
+        }
+    }
+    const reply = async (heard, replyOpts) => {
+        const signal = replyOpts?.signal;
+        try {
+            // Cache/phatic/joke answers do not need the companion LLM or grounded
+            // agent. Resolve this small dependency first so a cold process preserves
+            // the same instant route as a warm process.
+            await ensureFastReply();
+            const introspectionIntent = classifyLisaIntrospection(heard);
+            const recentHistory = conversationHistory(heard);
+            const pending = pendingShortcut;
+            pendingShortcut = null;
+            // Identity/boundary canned lines ("qui es-tu ?", "es-tu consciente ?")
+            // used to pre-empt technical introspection before the classifier ran. An
+            // introspection request must reach live evidence instead of a static line.
+            const shortcut = introspectionIntent
+                ? null
+                : pending?.heard === heard && pending.expiresAt >= Date.now()
+                    ? pending.reply
+                    : shortcutFor(heard, recentHistory);
+            if (shortcut) {
+                // Relationship evolution is best-effort and must not delay an answer
+                // that was explicitly precomputed for immediate delivery.
+                void evolveRelationshipFromUtterance(heard);
+                const safeShortcut = guardBeforeMemory(shortcut);
+                remember(heard, safeShortcut);
+                return safeShortcut;
+            }
+            // Lisa selfie — cache-first, before the LLM (companion profile has no tools).
+            if (process.env.CODEBUDDY_LISA_SELFIE !== 'false'
+                && (await import('../channels/companion-channel-profile.js')).isCompanionSurfaceEnabled()
+                && !introspectionIntent) {
+                try {
+                    const { tryServeCompanionSelfie } = await import('../companion/lisa-selfie-router.js');
+                    const selfie = await tryServeCompanionSelfie(heard, {
+                        surface: 'voice',
+                        includeImageBytes: false,
+                        rootDir: options.cwd ?? process.cwd(),
+                    });
+                    if (selfie) {
+                        void evolveRelationshipFromUtterance(heard);
+                        if (selfie.imagePath) {
+                            try {
+                                const env = process.env;
+                                if (env.CODEBUDDY_SENSORY_ALERT_TOKEN && env.CODEBUDDY_SENSORY_ALERT_CHAT) {
+                                    const { sendTelegramAlert } = await import('./alert.js');
+                                    await sendTelegramAlert(selfie.caption, selfie.imagePath);
+                                }
+                            }
+                            catch (sendErr) {
+                                logger.warn(`[voice-hybrid] lisa-selfie telegram skipped: ${sendErr instanceof Error ? sendErr.message : String(sendErr)}`);
+                            }
+                        }
+                        const line = guardBeforeMemory(selfie.caption);
+                        remember(heard, line);
+                        logger.info(`[voice-hybrid] lisa-selfie cache=${selfie.reason} image=${Boolean(selfie.imagePath)}`);
+                        return line;
+                    }
+                }
+                catch (err) {
+                    logger.warn(`[voice-hybrid] lisa-selfie skipped: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            try {
+                const { maybeHandleCameraShareRequest } = await import('../companion/camera-share.js');
+                const share = await maybeHandleCameraShareRequest(heard, {
+                    surface: 'voice',
+                    rootDir: options.cwd ?? process.cwd(),
+                });
+                if (share) {
+                    void evolveRelationshipFromUtterance(heard);
+                    const line = guardBeforeMemory(share.spokenReply);
+                    remember(heard, line);
+                    logger.info(`[voice-hybrid] camera-share success=${share.success} telegram=${share.telegramSent}`);
+                    return line;
+                }
+            }
+            catch (err) {
+                logger.warn(`[voice-hybrid] camera-share skipped: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            await evolveRelationshipFromUtterance(heard);
+            await ensureDeps();
+            const substantive = introspectionIntent !== null || classify(heard, recentHistory);
+            let responseMainProvider;
+            let cognitiveEvidence;
+            const stepOpts = {
+                ...(replyOpts ?? {}),
+                relationshipEvolutionHandled: true,
+                ...(options.acquireCognitiveContext
+                    ? { acquireCognitiveContext: options.acquireCognitiveContext }
+                    : {}),
+                onProviderResolved: (route) => {
+                    replyOpts?.onProviderResolved?.(route);
+                    if (!route.baseURL)
+                        return;
+                    responseMainProvider = {
+                        apiKey: route.apiKey,
+                        baseURL: route.baseURL,
+                        model: route.model,
+                    };
+                },
+                onCognitiveContextResolved: (context) => {
+                    replyOpts?.onCognitiveContextResolved?.(context);
+                    cognitiveEvidence = context.evidence || undefined;
+                },
+            };
+            let out = '';
+            let freshEvidence;
+            let prepared = prepareConversationTurn(heard, recentHistory);
+            if (substantive) {
+                const preamble = buildContextPreamble(recentHistory);
+                const freshContext = process.env.CODEBUDDY_PREFETCH === 'false'
+                    ? null
+                    : resolvePrefetchedTurnContextForConversation(heard, recentHistory, {
+                        allowStale: true,
+                    });
+                if (freshContext?.freshness === 'stale') {
+                    void runPrefetchCycle().catch(() => undefined);
+                }
+                freshEvidence = semanticReviewEvidenceFromPrefetch(freshContext);
+                prepared = prepareConversationTurn(heard, recentHistory, {
+                    ...(freshContext ? { freshContext: freshContext.promptGuidance } : {}),
+                });
+                const input = [preamble, prepared.systemGuidance, `Demande actuelle : ${heard}`]
+                    .filter(Boolean)
+                    .join('\n\n');
+                out = (await agentReply(input, {
+                    ...(stepOpts ?? {}),
+                    // `input` deliberately carries recent history. Preserve the exact
+                    // current utterance separately so the agent cannot classify an old
+                    // introspection question as the intent of this turn.
+                    introspectionText: heard,
+                })).trim();
+            }
+            else {
+                out = (await chitchat(heard, recentHistory, stepOpts)).trim();
+            }
+            if (!out && !signal?.aborted)
+                out = conversationFailureReply(heard, recentHistory);
+            if (out && !signal?.aborted) {
+                out = guardBeforeMemory(out);
+                const reviewEvidence = mergeEvidence(freshEvidence, cognitiveEvidence);
+                const reviewInput = {
+                    request: heard,
+                    draft: out,
+                    plan: prepared.plan,
+                    history: recentHistory,
+                    ...(reviewEvidence ? { evidence: reviewEvidence } : {}),
+                    ...(responseMainProvider ? { mainProvider: responseMainProvider } : {}),
+                    ...(signal ? { signal } : {}),
+                };
+                if (replyOpts?.onSemanticCorrection && shouldReviewPlan(prepared.plan, heard)) {
+                    const correction = reviewBeforeDelivery(reviewInput, stepOpts)
+                        .then((reviewed) => briefSemanticCorrection(out, reviewed))
+                        .catch(() => '');
+                    try {
+                        replyOpts.onSemanticCorrection(correction);
+                    }
+                    catch {
+                        /* the audio correction channel is optional; initial delivery stays non-blocking */
+                    }
+                }
+                else {
+                    const reviewed = await reviewBeforeDelivery(reviewInput, stepOpts);
+                    if (reviewed)
+                        out = guardBeforeMemory(reviewed.response.trim() || out);
+                }
+            }
+            if (signal?.aborted)
+                return '';
+            remember(heard, out);
+            const quality = assessConversationResponse(heard, out, recentHistory);
+            logger.info(`[voice-hybrid] route=${substantive ? 'agent' : 'chitchat'} responseChars=${out.length}`);
+            logger.info(`[voice-hybrid] quality score=${quality.score.toFixed(2)} sentences=${quality.sentenceCount} reasoningLinks=${quality.reasoningLinkCount} issues=${quality.issues.join(',') || 'none'}`);
+            return out;
+        }
+        catch (err) {
+            logger.warn(`[voice-hybrid] failed: ${err instanceof Error ? err.message : String(err)}`);
+            return signal?.aborted ? '' : conversationFailureReply(heard, conversationHistory(heard));
+        }
+    };
+    reply.spokenPrefix = async (heard, replyOpts) => {
+        if (replyOpts?.signal?.aborted)
+            return '';
+        const startedAt = Date.now();
+        try {
+            const recent = conversationHistory(heard);
+            if (sensoryShortFirstEnabled() &&
+                classifyLisaIntrospection(heard) === null &&
+                !classify(heard, recent)) {
+                return '';
+            }
+            const route = await resolveVoiceModel(heard, { history: recent });
+            if (!voiceLatencyBufferEnabled(process.env.CODEBUDDY_VOICE_SPOKEN_PREFIX, route.baseURL))
+                return '';
+            const prepared = prepareConversationTurn(heard, recent);
+            if (!isSpokenPrefixEligible(heard, prepared.plan)) {
+                reportPrefixCause(replyOpts, 'ineligible');
+                return '';
+            }
+            await ensureDeps();
+            let mainProvider;
+            const prefixOptions = {
+                ...(replyOpts ?? {}),
+                onProviderResolved: (route) => {
+                    replyOpts?.onProviderResolved?.(route);
+                    if (!route.baseURL)
+                        return;
+                    mainProvider = {
+                        apiKey: route.apiKey,
+                        baseURL: route.baseURL,
+                        model: route.model,
+                    };
+                },
+            };
+            const draft = await prefixReply(heard, recent, prefixOptions);
+            if (replyOpts?.signal?.aborted)
+                return '';
+            const accepted = await reviewPrefixBeforeDelivery({
+                request: heard,
+                draft,
+                plan: prepared.plan,
+                history: recent,
+                ...(mainProvider ? { mainProvider } : {}),
+                ...(replyOpts?.signal ? { signal: replyOpts.signal } : {}),
+            }, prefixOptions);
+            if (accepted) {
+                logger.info(`[voice-hybrid] spoken prefix ready ms=${Date.now() - startedAt}`);
+            }
+            return accepted;
+        }
+        catch (error) {
+            reportPrefixCause(replyOpts, 'empty');
+            logger.warn(`[voice-hybrid] spoken prefix failed closed (${error instanceof Error ? error.name : 'unknown'})`);
+            return '';
+        }
+    };
+    reply.stream = async function* (heard, replyOpts) {
+        try {
+            await ensureFastReply();
+            const introspectionIntent = classifyLisaIntrospection(heard);
+            const recent = conversationHistory(heard);
+            // An instant answer is already complete text, but it still benefits from
+            // the sentence pipeline: the first cached-news sentence reaches Pocket or
+            // Voicebox immediately instead of synthesizing the entire bulletin first.
+            // Keep a short-lived copy only for the immediate blocking fallback so a
+            // stateful joke is never advanced twice when every audio path fails.
+            const shortcut = introspectionIntent ? null : shortcutFor(heard, recent);
+            if (shortcut) {
+                const safeShortcut = guardBeforeMemory(shortcut);
+                pendingShortcut = { heard, reply: safeShortcut, expiresAt: Date.now() + 2_000 };
+                yield safeShortcut;
+                if (!replyOpts?.signal?.aborted) {
+                    void evolveRelationshipFromUtterance(heard);
+                    remember(heard, safeShortcut);
+                }
+                return;
+            }
+            const substantive = introspectionIntent !== null || classify(heard, recent);
+            // Technical introspection stays on its deterministic whole-answer guard. Other grounded
+            // turns use the agent's text-delta stream when available; a failed stream with no
+            // complete sentence yields nothing so makeVoiceReply retains the proven blocking fallback.
+            if (introspectionIntent !== null)
+                return;
+            await ensureDeps(true);
+            if (substantive) {
+                if (!replyOpts?.spokenPrefix) {
+                    const agentStream = agentReply?.stream;
+                    if (!agentStream)
+                        return;
+                    const preamble = buildContextPreamble(recent);
+                    const freshContext = process.env.CODEBUDDY_PREFETCH === 'false'
+                        ? null
+                        : resolvePrefetchedTurnContextForConversation(heard, recent, { allowStale: true });
+                    if (freshContext?.freshness === 'stale') {
+                        void runPrefetchCycle().catch(() => undefined);
+                    }
+                    const freshEvidence = semanticReviewEvidenceFromPrefetch(freshContext);
+                    const prepared = prepareConversationTurn(heard, recent, {
+                        ...(freshContext ? { freshContext: freshContext.promptGuidance } : {}),
+                    });
+                    let responseMainProvider;
+                    let cognitiveEvidence;
+                    const streamOptions = {
+                        ...(replyOpts ?? {}),
+                        relationshipEvolutionHandled: true,
+                        ...(options.acquireCognitiveContext
+                            ? { acquireCognitiveContext: options.acquireCognitiveContext }
+                            : {}),
+                        onProviderResolved: (route) => {
+                            replyOpts?.onProviderResolved?.(route);
+                            if (!route.baseURL)
+                                return;
+                            responseMainProvider = {
+                                apiKey: route.apiKey,
+                                baseURL: route.baseURL,
+                                model: route.model,
+                            };
+                        },
+                        onCognitiveContextResolved: (context) => {
+                            replyOpts?.onCognitiveContextResolved?.(context);
+                            cognitiveEvidence = context.evidence || undefined;
+                        },
+                    };
+                    const input = [preamble, prepared.systemGuidance, `Demande actuelle : ${heard}`]
+                        .filter(Boolean)
+                        .join('\n\n');
+                    let full = '';
+                    try {
+                        for await (const delta of agentStream(input, {
+                            ...streamOptions,
+                            introspectionText: heard,
+                        })) {
+                            if (replyOpts?.signal?.aborted)
+                                return;
+                            if (typeof delta !== 'string' || delta.length === 0)
+                                continue;
+                            full += delta;
+                            yield delta;
+                        }
+                    }
+                    catch (error) {
+                        // A complete sentence may already be in the speaker's queue. Do not restart
+                        // the answer through the blocking route: close honestly and remember only this
+                        // actually released part. With no complete sentence, the outer catch remains
+                        // empty so makeVoiceReply can invoke the promised blocking fallback.
+                        if (!replyOpts?.signal?.aborted) {
+                            const spoken = guardBeforeMemory(completedStreamText(full));
+                            if (spoken) {
+                                yield STREAM_FAILURE_CLOSURE;
+                                await evolveRelationshipFromUtterance(heard);
+                                remember(heard, `${spoken} ${STREAM_FAILURE_CLOSURE}`);
+                                logger.warn(`[voice-hybrid] agent stream interrupted after partial delivery: ${error instanceof Error ? error.message : String(error)}`);
+                                return;
+                            }
+                        }
+                        throw error;
+                    }
+                    if (replyOpts?.signal?.aborted)
+                        return;
+                    const completed = guardBeforeMemory(full.trim());
+                    let correction = '';
+                    if (completed && shouldReviewPlan(prepared.plan, heard)) {
+                        const reviewEvidence = mergeEvidence(freshEvidence, cognitiveEvidence);
+                        const reviewed = await reviewBeforeDelivery({
+                            request: heard,
+                            draft: completed,
+                            plan: prepared.plan,
+                            history: recent,
+                            ...(reviewEvidence ? { evidence: reviewEvidence } : {}),
+                            ...(responseMainProvider ? { mainProvider: responseMainProvider } : {}),
+                            ...(replyOpts?.signal ? { signal: replyOpts.signal } : {}),
+                        }, streamOptions);
+                        correction = briefSemanticCorrection(completed, reviewed);
+                        if (replyOpts?.signal?.aborted)
+                            return;
+                        if (correction)
+                            yield ` ${correction}`;
+                    }
+                    if (completed) {
+                        await evolveRelationshipFromUtterance(heard);
+                        const canonical = [completed, correction].filter(Boolean).join(' ');
+                        remember(heard, canonical);
+                        logger.info(`[voice-hybrid] route=agent-stream responseChars=${canonical.length}`);
+                    }
+                    return;
+                }
+                const spokenPrefix = replyOpts.spokenPrefix.trim();
+                const preamble = buildContextPreamble(recent);
+                const freshContext = process.env.CODEBUDDY_PREFETCH === 'false'
+                    ? null
+                    : resolvePrefetchedTurnContextForConversation(heard, recent, { allowStale: true });
+                const freshEvidence = semanticReviewEvidenceFromPrefetch(freshContext);
+                const prepared = prepareConversationTurn(heard, recent, {
+                    ...(freshContext ? { freshContext: freshContext.promptGuidance } : {}),
+                });
+                let responseMainProvider;
+                let cognitiveEvidence;
+                const continuationOptions = {
+                    ...(replyOpts ?? {}),
+                    relationshipEvolutionHandled: true,
+                    ...(options.acquireCognitiveContext
+                        ? { acquireCognitiveContext: options.acquireCognitiveContext }
+                        : {}),
+                    spokenPrefix,
+                    onProviderResolved: (route) => {
+                        replyOpts?.onProviderResolved?.(route);
+                        if (!route.baseURL)
+                            return;
+                        responseMainProvider = {
+                            apiKey: route.apiKey,
+                            baseURL: route.baseURL,
+                            model: route.model,
+                        };
+                    },
+                    onCognitiveContextResolved: (context) => {
+                        replyOpts?.onCognitiveContextResolved?.(context);
+                        cognitiveEvidence = context.evidence || undefined;
+                    },
+                };
+                const input = [preamble, prepared.systemGuidance, `Demande actuelle : ${heard}`]
+                    .filter(Boolean)
+                    .join('\n\n');
+                let completed = '';
+                try {
+                    completed = (await agentReply(input, {
+                        ...continuationOptions,
+                        introspectionText: heard,
+                    })).trim();
+                }
+                catch (error) {
+                    if (!replyOpts?.signal?.aborted && spokenPrefix) {
+                        yield STREAM_FAILURE_CLOSURE;
+                        await evolveRelationshipFromUtterance(heard);
+                        remember(heard, `${spokenPrefix} ${STREAM_FAILURE_CLOSURE}`);
+                        logger.warn(`[voice-hybrid] prefixed reply interrupted after prefix delivery: ${error instanceof Error ? error.message : String(error)}`);
+                        return;
+                    }
+                    throw error;
+                }
+                if (replyOpts?.signal?.aborted)
+                    return;
+                completed = guardBeforeMemory(removeRepeatedPrefix(spokenPrefix, completed));
+                if (!completed) {
+                    yield STREAM_FAILURE_CLOSURE;
+                    await evolveRelationshipFromUtterance(heard);
+                    remember(heard, `${spokenPrefix} ${STREAM_FAILURE_CLOSURE}`);
+                    return;
+                }
+                if (completed)
+                    yield completed;
+                let correction = '';
+                if (completed && shouldReviewPlan(prepared.plan, heard)) {
+                    const reviewEvidence = mergeEvidence(freshEvidence, cognitiveEvidence);
+                    const reviewed = await reviewBeforeDelivery({
+                        request: heard,
+                        draft: completed,
+                        plan: prepared.plan,
+                        history: [...recent, { role: 'assistant', content: spokenPrefix }],
+                        ...(reviewEvidence ? { evidence: reviewEvidence } : {}),
+                        ...(responseMainProvider ? { mainProvider: responseMainProvider } : {}),
+                        ...(replyOpts?.signal ? { signal: replyOpts.signal } : {}),
+                    }, continuationOptions);
+                    correction = briefSemanticCorrection(completed, reviewed);
+                    if (correction && !replyOpts?.signal?.aborted)
+                        yield ` ${correction}`;
+                }
+                if (replyOpts?.signal?.aborted)
+                    return;
+                const canonical = [spokenPrefix, completed, correction].filter(Boolean).join(' ');
+                if (canonical) {
+                    await evolveRelationshipFromUtterance(heard);
+                    remember(heard, canonical);
+                    logger.info(`[voice-hybrid] route=agent-prefixed responseChars=${canonical.length}`);
+                }
+                return;
+            }
+            const prepared = prepareConversationTurn(heard, recent);
+            // A prefixed continuation must be buffered even when no semantic critic is required:
+            // this lets us remove an accidental repeated prefix before any continuation is emitted.
+            const prefixBuffer = Boolean(replyOpts?.spokenPrefix);
+            let full = '';
+            let responseMainProvider;
+            let cognitiveEvidence;
+            const shortFirst = sensoryShortFirstEnabled()
+                ? { maxSentences: sensoryReplyMaxSentences() }
+                : undefined;
+            const reviewShortFirstBeforeDelivery = Boolean(shortFirst && shouldReviewPlan(prepared.plan, heard));
+            let shortFirstSentenceCount = 0;
+            const streamOptions = {
+                ...(replyOpts ?? {}),
+                relationshipEvolutionHandled: true,
+                ...(shortFirst ? { shortFirst } : {}),
+                ...(options.acquireCognitiveContext
+                    ? { acquireCognitiveContext: options.acquireCognitiveContext }
+                    : {}),
+                onProviderResolved: (route) => {
+                    replyOpts?.onProviderResolved?.(route);
+                    if (!route.baseURL)
+                        return;
+                    responseMainProvider = {
+                        apiKey: route.apiKey,
+                        baseURL: route.baseURL,
+                        model: route.model,
+                    };
+                },
+                onCognitiveContextResolved: (context) => {
+                    replyOpts?.onCognitiveContextResolved?.(context);
+                    cognitiveEvidence = context.evidence || undefined;
+                },
+            };
+            if (shortFirst)
+                replyOpts?.onShortFirstReady?.(shortFirst);
+            try {
+                const source = chitchatStream(heard, recent, streamOptions);
+                const delivered = shortFirst
+                    ? shortFirstSentenceStream(source, shortFirst.maxSentences, replyOpts?.signal)
+                    : source;
+                for await (const delta of delivered) {
+                    if (replyOpts?.signal?.aborted)
+                        return;
+                    if (typeof delta !== 'string' || delta.length === 0)
+                        continue;
+                    if (shortFirst)
+                        shortFirstSentenceCount += 1;
+                    full += delta;
+                    if (!prefixBuffer && !reviewShortFirstBeforeDelivery)
+                        yield delta;
+                }
+            }
+            catch (error) {
+                if (!replyOpts?.signal?.aborted) {
+                    const spoken = guardBeforeMemory(prefixBuffer
+                        ? replyOpts?.spokenPrefix?.trim() ?? ''
+                        : completedStreamText(full));
+                    if (spoken) {
+                        yield STREAM_FAILURE_CLOSURE;
+                        await evolveRelationshipFromUtterance(heard);
+                        remember(heard, `${spoken} ${STREAM_FAILURE_CLOSURE}`);
+                        logger.warn(`[voice-hybrid] chitchat stream interrupted after partial delivery: ${error instanceof Error ? error.message : String(error)}`);
+                        return;
+                    }
+                }
+                throw error;
+            }
+            let completed = full.trim();
+            if (completed) {
+                completed = guardBeforeMemory(removeRepeatedPrefix(replyOpts?.spokenPrefix ?? '', completed));
+            }
+            if (completed && reviewShortFirstBeforeDelivery && !replyOpts?.signal?.aborted) {
+                const reviewed = await reviewBeforeDelivery({
+                    request: heard,
+                    draft: completed,
+                    plan: prepared.plan,
+                    history: replyOpts?.spokenPrefix
+                        ? [...recent, { role: 'assistant', content: replyOpts.spokenPrefix }]
+                        : recent,
+                    ...(cognitiveEvidence ? { evidence: cognitiveEvidence } : {}),
+                    ...(responseMainProvider ? { mainProvider: responseMainProvider } : {}),
+                    ...(replyOpts?.signal ? { signal: replyOpts.signal } : {}),
+                }, streamOptions);
+                if (replyOpts?.signal?.aborted)
+                    return;
+                const approved = guardBeforeMemory(reviewed?.response.trim() || completed);
+                const approvedParts = [];
+                for await (const delta of shortFirstSentenceStream(singleTextStream(approved), shortFirst.maxSentences, replyOpts?.signal)) {
+                    approvedParts.push(delta.trim());
+                    yield delta;
+                }
+                completed = approvedParts.join(' ');
+                shortFirstSentenceCount = approvedParts.length;
+            }
+            else if (completed && prefixBuffer && !replyOpts?.signal?.aborted) {
+                yield completed;
+            }
+            let correction = '';
+            if (completed &&
+                !reviewShortFirstBeforeDelivery &&
+                shouldReviewPlan(prepared.plan, heard) &&
+                (!shortFirst || shortFirstSentenceCount < shortFirst.maxSentences) &&
+                !replyOpts?.signal?.aborted) {
+                const reviewed = await reviewBeforeDelivery({
+                    request: heard,
+                    draft: completed,
+                    plan: prepared.plan,
+                    history: replyOpts?.spokenPrefix
+                        ? [...recent, { role: 'assistant', content: replyOpts.spokenPrefix }]
+                        : recent,
+                    ...(cognitiveEvidence ? { evidence: cognitiveEvidence } : {}),
+                    ...(responseMainProvider ? { mainProvider: responseMainProvider } : {}),
+                    ...(replyOpts?.signal ? { signal: replyOpts.signal } : {}),
+                }, streamOptions);
+                correction = briefSemanticCorrection(completed, reviewed);
+                if (replyOpts?.signal?.aborted)
+                    return;
+                if (correction && shortFirst) {
+                    const limitedCorrection = [];
+                    const remaining = shortFirst.maxSentences - shortFirstSentenceCount;
+                    for await (const delta of shortFirstSentenceStream(singleTextStream(correction), remaining, replyOpts?.signal)) {
+                        limitedCorrection.push(delta.trim());
+                        yield ` ${delta}`;
+                    }
+                    correction = limitedCorrection.join(' ');
+                }
+                else if (correction) {
+                    yield ` ${correction}`;
+                }
+            }
+            if (completed && !replyOpts?.signal?.aborted) {
+                await evolveRelationshipFromUtterance(heard);
+                remember(heard, [replyOpts?.spokenPrefix, completed, correction].filter(Boolean).join(' '));
+                logger.info(`[voice-hybrid] route=chitchat-stream responseChars=${completed.length}`);
+            }
+        }
+        catch (err) {
+            logger.warn(`[voice-hybrid] stream failed: ${err instanceof Error ? err.message : String(err)}`);
+            // Yielding nothing lets the voice loop retry through the blocking path.
+        }
+    };
+    reply.prewarm = async (transcriptHint) => {
+        await ensureDeps();
+        await agentReply.prewarm?.(transcriptHint);
+    };
+    reply.dispose = () => {
+        agentReply?.dispose?.();
+    };
+    return reply;
+}
+//# sourceMappingURL=hybrid-reply.js.map