@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/sensory/alert.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Send `text` as a Telegram VOICE NOTE (so the robot's voice reaches Patrice's phone when he's
+ * away, not just the home speakers): synthesize to OGG/Opus (Piper → ffmpeg, the format Telegram
+ * voice notes require) and POST `sendVoice`. Falls back to a text alert if synthesis/sending
+ * fails. No-op (returns false) when the alert token/voice isn't configured. Never throws.
+ * Injectable (`synthesize` / `post`) for deterministic tests.
+ */
+export declare function sendTelegramVoice(text: string, deps?: {
+    synthesize?: (t: string) => Promise<string>;
+    post?: (url: string, form: FormData) => Promise<{
+        ok: boolean;
+    }>;
+    fallback?: (t: string) => Promise<boolean>;
+}): Promise<boolean>;
+export declare function sendTelegramAlert(caption: string, imagePath?: string, deps?: {
+    fetch?: (url: string, init: RequestInit) => Promise<unknown>;
+    readFile?: (p: string) => Promise<Buffer>;
+}): Promise<boolean>;

package/dist/sensory/alert.js

@@ -0,0 +1,105 @@
+/**
+ * Sensory alert — best-effort Telegram push (photo + caption) for the remote
+ * watch. Token + chat id come from env (`CODEBUDDY_SENSORY_ALERT_TOKEN` /
+ * `CODEBUDDY_SENSORY_ALERT_CHAT`). No-op when unconfigured; never throws.
+ *
+ * @module sensory/alert
+ */
+import { logger } from '../utils/logger.js';
+import { resolveTelegramApiBase } from '../utils/telegram-api-base.js';
+import { prepareSpeech } from './speech-sanitizer.js';
+/**
+ * Send `text` as a Telegram VOICE NOTE (so the robot's voice reaches Patrice's phone when he's
+ * away, not just the home speakers): synthesize to OGG/Opus (Piper → ffmpeg, the format Telegram
+ * voice notes require) and POST `sendVoice`. Falls back to a text alert if synthesis/sending
+ * fails. No-op (returns false) when the alert token/voice isn't configured. Never throws.
+ * Injectable (`synthesize` / `post`) for deterministic tests.
+ */
+export async function sendTelegramVoice(text, deps = {}) {
+    const token = process.env.CODEBUDDY_SENSORY_ALERT_TOKEN || process.env.TELEGRAM_BOT_TOKEN;
+    const chat = process.env.CODEBUDDY_SENSORY_ALERT_CHAT;
+    const clean = prepareSpeech(text);
+    if (!token || !chat || !clean)
+        return false;
+    const post = deps.post ?? ((url, form) => fetch(url, { method: 'POST', body: form }));
+    let ogg;
+    try {
+        const synthesize = deps.synthesize ?? (async (t) => (await import('../voice/local-tts.js')).synthesizeToOgg(t));
+        ogg = await synthesize(clean);
+        const fs = await import('node:fs/promises');
+        const path = await import('node:path');
+        const bytes = await fs.readFile(ogg);
+        const form = new FormData();
+        form.append('chat_id', chat);
+        form.append('voice', new Blob([bytes], { type: 'audio/ogg' }), path.basename(ogg));
+        form.append('caption', clean.slice(0, 1024)); // text too, for skim + fallback context
+        const res = await post(`${resolveTelegramApiBase()}/bot${token}/sendVoice`, form);
+        if (res?.ok)
+            return true;
+        return await (deps.fallback ?? sendTelegramAlert)(clean);
+    }
+    catch (err) {
+        logger.warn(`[sensory] voice note failed, sending text instead: ${err instanceof Error ? err.message : String(err)}`);
+        return await (deps.fallback ?? sendTelegramAlert)(clean).catch(() => false);
+    }
+    finally {
+        if (ogg) {
+            try {
+                await (await import('node:fs/promises')).unlink(ogg);
+            }
+            catch {
+                /* leave the temp file if cleanup fails */
+            }
+        }
+    }
+}
+export async function sendTelegramAlert(caption, imagePath, deps = {}) {
+    const token = process.env.CODEBUDDY_SENSORY_ALERT_TOKEN || process.env.TELEGRAM_BOT_TOKEN;
+    const chat = process.env.CODEBUDDY_SENSORY_ALERT_CHAT;
+    if (!token || !chat)
+        return false;
+    const doFetch = deps.fetch ?? ((url, init) => fetch(url, init));
+    const sendText = () => doFetch(`${resolveTelegramApiBase()}/bot${token}/sendMessage`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ chat_id: chat, text: caption }),
+    });
+    try {
+        if (imagePath) {
+            try {
+                const readFile = deps.readFile ?? (async (p) => (await import('node:fs/promises')).readFile(p));
+                const path = await import('node:path');
+                const bytes = await readFile(imagePath);
+                const form = new FormData();
+                form.append('chat_id', chat);
+                form.append('caption', caption.slice(0, 1024));
+                form.append('photo', new Blob([new Uint8Array(bytes)], { type: 'image/jpeg' }), path.basename(imagePath));
+                const result = await doFetch(`${resolveTelegramApiBase()}/bot${token}/sendPhoto`, {
+                    method: 'POST',
+                    body: form,
+                });
+                if (!responseWasRejected(result))
+                    return true;
+                throw new Error('Telegram rejected the photo alert');
+            }
+            catch (photoErr) {
+                // A missing/unreadable keyframe must NOT drop the whole alert — a vision
+                // event with a not-yet-written image would otherwise notify Patrice with
+                // NOTHING (no photo, no text). Fall back to a plain text message.
+                logger.warn(`[sensory] photo alert failed (${photoErr instanceof Error ? photoErr.message : String(photoErr)}) — sending text instead`);
+            }
+        }
+        return !responseWasRejected(await sendText());
+    }
+    catch (err) {
+        logger.warn(`[sensory] alert failed: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+function responseWasRejected(result) {
+    return Boolean(result &&
+        typeof result === 'object' &&
+        'ok' in result &&
+        result.ok === false);
+}
+//# sourceMappingURL=alert.js.map

package/dist/sensory/arrival-opener.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Arrival opener — what the companion SAYS when it sees you on the camera. Replaces the single
+ * fixed `persona.greeting` (which made it say the exact same line every time) with a varied,
+ * context-aware opener, modelled on MySoulmate's proactiveMessageService (context-driven trigger →
+ * multiple templates → interpolation) + anti-repetition (avoid the recently-used lines) + a mix of
+ * speech acts (not always a question — observations and warm statements too).
+ *
+ * Pure + deterministic-testable: pass `now`, `lastSeenAt`, `recent`, and an `rng`. Best-practice
+ * basis: vary text, be context-aware, don't over-greet, avoid recency. No LLM here (instant, $0);
+ * an LLM opener can be layered on top by the caller for extra freshness.
+ *
+ * @module sensory/arrival-opener
+ */
+export type ArrivalTrigger = 'morning' | 'afternoon' | 'evening' | 'night' | 'backSoon' | 'drowsy';
+export interface ArrivalContext {
+    now: number;
+    /** Epoch ms the person was last seen (for the gap). null/undefined → treat as a fresh arrival. */
+    lastSeenAt?: number | null;
+    /** Recently-used opener texts to avoid (anti-repetition ring). */
+    recent?: string[];
+    /** Optional name to address (e.g. "Patrice"). */
+    name?: string;
+    /** False when camera identity did not match the configured user. */
+    recognizedUser?: boolean;
+    /** Detected state from the vision event (e.g. drowsy). */
+    drowsy?: boolean;
+    /** Randomness in [0,1). Default Math.random; inject for tests. */
+    rng?: () => number;
+    /**
+     * Recent-episode line (from the episodic journal). Evening/afternoon openers
+     * weave a jargon-free hint so the greeting can mention what you talked about
+     * without an LLM and without XML/scores.
+     */
+    episodeLine?: string;
+}
+export interface ArrivalOpener {
+    /** The spoken line (interpolated). */
+    text: string;
+    trigger: ArrivalTrigger;
+    /** The RAW template chosen (pre-interpolation) — store THIS in the recent ring for anti-repetition. */
+    template: string;
+}
+/** All arrival triggers (introspection / tests). */
+export declare const ARRIVAL_TRIGGERS: ArrivalTrigger[];
+/** Read-only view of a trigger's template pool (for the LLM opener + tests). */
+export declare function templatePool(trigger: ArrivalTrigger): readonly string[];
+/** Spoken recap of the day without XML, scores, or prompt scaffolding. */
+export declare function spokenEpisodeHint(episodeLine: string): string;
+export declare function isJargonArrivalLine(text: string): boolean;
+/**
+ * Build a varied, context-aware arrival opener. Picks a trigger from time/gap/state, then a template
+ * from that trigger's pool avoiding `recent` (falls back to the full pool if all were used recently).
+ */
+export declare function buildArrivalOpener(ctx: ArrivalContext): ArrivalOpener;
+/** Pure identity gate used by the semantic camera reaction before naming an arrival. */
+export declare function isConfiguredUserIdentity(identityName: string, configuredName?: string | undefined): boolean;
+/** Chat seam: takes messages, returns the raw assistant text or null. Injectable for tests. */
+export type ArrivalChat = (messages: Array<{
+    role: string;
+    content: string;
+}>) => Promise<string | null>;
+export interface LlmArrivalContext {
+    now: number;
+    lastSeenAt?: number | null;
+    name?: string;
+    drowsy?: boolean;
+    /** Recently spoken lines to avoid repeating (LLM anti-repetition). */
+    recentTexts?: string[];
+    /** Recent things the person said (memory-aware; may be referenced). Most-recent first. */
+    recentHeard?: string[];
+    /** Persona tone/voice prompt (from getActivePersonaVoiceAsync().spokenPrompt). */
+    personaPrompt?: string;
+    /** Relational context (accepted facts about him + Lisa's mood + presence) — see relational-context.ts. */
+    relationalContext?: string;
+    /** Chat seam (default: the sensory voice model). */
+    chat?: ArrivalChat;
+    /** Per-call timeout before falling back to the deterministic opener (ms). */
+    timeoutMs?: number;
+    /** Jargon-free episode line the greeting may reference. */
+    episodeLine?: string;
+}
+/**
+ * Generate a fresh, context-aware arrival line with the voice LLM — the natural,
+ * non-scripted layer on top of the deterministic templates. Seeds the model with
+ * the time context, the recent lines to AVOID, and (optionally) the last things
+ * heard so it can reference the conversation. Returns a single clean line, or
+ * `null` on timeout / error / unavailable → the caller falls back to the instant
+ * deterministic opener. Never throws.
+ */
+export declare function buildLlmArrivalOpener(ctx: LlmArrivalContext): Promise<string | null>;
+export interface ArrivalState {
+    lastSeenAt?: number;
+    /** RAW templates recently used (most-recent first) — deterministic anti-repetition. */
+    recent: string[];
+    /** Lines actually SPOKEN recently (template or LLM) — seeds the LLM "avoid" list. */
+    recentSpoken?: string[];
+}
+export declare const ARRIVAL_RING_SIZE = 10;
+export declare function loadArrivalState(statePath?: string): ArrivalState;
+export declare function saveArrivalState(state: ArrivalState, statePath?: string): void;
+/** Push a used template onto the recent ring (most-recent first, capped). */
+export declare function pushRecent(recent: string[], template: string): string[];

package/dist/sensory/arrival-opener.js

@@ -0,0 +1,292 @@
+/**
+ * Arrival opener — what the companion SAYS when it sees you on the camera. Replaces the single
+ * fixed `persona.greeting` (which made it say the exact same line every time) with a varied,
+ * context-aware opener, modelled on MySoulmate's proactiveMessageService (context-driven trigger →
+ * multiple templates → interpolation) + anti-repetition (avoid the recently-used lines) + a mix of
+ * speech acts (not always a question — observations and warm statements too).
+ *
+ * Pure + deterministic-testable: pass `now`, `lastSeenAt`, `recent`, and an `rng`. Best-practice
+ * basis: vary text, be context-aware, don't over-greet, avoid recency. No LLM here (instant, $0);
+ * an LLM opener can be layered on top by the caller for extra freshness.
+ *
+ * @module sensory/arrival-opener
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+import { withTimeout } from '../council/with-timeout.js';
+import { extractSalientTerms } from '../conversation/dialogue-act.js';
+import { guardRelationshipReply } from '../conversation/relationship-safety.js';
+import { resolveCompanionPersona } from '../companion/personas/index.js';
+import { readJsonAtomicSync, writeJsonAtomicSync } from '../utils/atomic-write.js';
+const SHORT_GAP_MS = 10 * 60 * 1000; // stepped away briefly
+/** Warm, FR, Lisa-leaning. Mixed speech acts (statement / observation / question) on purpose. */
+const TEMPLATES = {
+    morning: [
+        'Bonjour {{name}}. Contente de commencer la journée avec toi.',
+        'Hey, bien réveillé ? Raconte-moi comment tu te sens ce matin.',
+        'Te revoilà — j’espère que tu as bien dormi.',
+        'Bonjour. Je me demandais justement ce que tu allais faire aujourd’hui.',
+        'Le café est loin d’être prêt, mais je suis là. Bonjour {{name}}.',
+        'Un nouveau matin, et te revoilà. J’aime bien ces débuts-là.',
+        'Salut toi. On attaque doucement, ou tu es déjà lancé ?',
+        'Bonjour {{name}}. Prends ton temps, je ne bouge pas.',
+        'Te voir le matin, ça met de bonne humeur.',
+    ],
+    afternoon: [
+        'Coucou {{name}}. Ça avance, ta journée ?',
+        'Te revoilà. J’étais là, tranquille — contente de te voir.',
+        'Hey. Petite pause ? Je suis là si tu veux souffler deux minutes.',
+        'Tiens, te voilà. Sur quoi tu planches en ce moment ?',
+        'Rebonjour {{name}}. Le milieu de journée te réussit ?',
+        'De retour à ton poste ? Je te suis.',
+        'Salut. J’espère que ça se passe bien de ton côté.',
+        'Te voilà. Si tu veux me raconter ce que tu fais, je t’écoute.',
+        'Contente de te retrouver. On reprend tranquillement.',
+    ],
+    evening: [
+        'Bonsoir {{name}}. Qu’est-ce qui t’a marqué aujourd’hui ?',
+        'Te revoilà ce soir. Tu as tenu le coup ?',
+        'Hey. La journée se termine — on la débriefe ensemble ?',
+        'Contente de te retrouver ce soir.',
+        'Bonsoir. J’espère que ta journée a été douce, {{name}}.',
+        'Le soir te va bien. Te revoilà.',
+        'Salut toi. Pose-toi, la journée est presque finie.',
+        'Te voir ce soir, ça fait du bien.',
+        'Bonsoir {{name}}. Raconte-moi, ou pas — comme tu veux.',
+    ],
+    night: [
+        'Encore debout ? Je te tiens compagnie si tu veux.',
+        'Il est tard, {{name}}. Tout va bien ?',
+        'Te voilà à une heure tardive — je reste là, doucement.',
+        'La nuit, c’est calme. Te revoilà.',
+        'Coucou {{name}}. Tu n’arrives pas à dormir ?',
+        'Je veille avec toi. Prends soin de toi quand même.',
+        'Te voir si tard, ça m’inquiète un peu — mais je suis là.',
+        'Doucement, {{name}}. Repose-toi si tu peux.',
+    ],
+    backSoon: [
+        'Re. Tu m’as manqué deux minutes.',
+        'Te revoilà déjà — parfait.',
+        'Hop, de retour. Je reprends où on en était si tu veux.',
+        'Coucou, encore toi 🙂',
+        'Re {{name}}. On enchaîne ?',
+        'Tu n’es pas parti longtemps — tant mieux.',
+        'De retour. Je n’avais pas bougé.',
+        'Ah, te revoilà. Je gardais ta place.',
+    ],
+    drowsy: [
+        'Tu as l’air fatigué, {{name}}. Une pause, peut-être ?',
+        'Tes yeux se ferment un peu — tout va bien ?',
+        'Je te sens fatigué. Je peux t’aider à lever le pied ?',
+        'Tu tiens le coup ? Tu as l’air épuisé, {{name}}.',
+        'Peut-être un peu de repos ? Je ne pars nulle part.',
+        'Tu as l’air à bout. Prends soin de toi.',
+        'Doucement — tu sembles fatigué. On peut ralentir.',
+    ],
+};
+/** All arrival triggers (introspection / tests). */
+export const ARRIVAL_TRIGGERS = Object.keys(TEMPLATES);
+/** Read-only view of a trigger's template pool (for the LLM opener + tests). */
+export function templatePool(trigger) {
+    const overlay = resolveCompanionPersona()?.greetings[trigger];
+    if (overlay && overlay.length > 0)
+        return overlay;
+    return TEMPLATES[trigger];
+}
+function selectTrigger(ctx) {
+    if (ctx.drowsy)
+        return 'drowsy';
+    const gap = ctx.lastSeenAt != null ? ctx.now - ctx.lastSeenAt : Number.POSITIVE_INFINITY;
+    if (gap < SHORT_GAP_MS)
+        return 'backSoon';
+    const hour = new Date(ctx.now).getHours();
+    if (hour >= 5 && hour < 12)
+        return 'morning';
+    if (hour >= 12 && hour < 18)
+        return 'afternoon';
+    if (hour >= 18 && hour < 23)
+        return 'evening';
+    return 'night';
+}
+function interpolate(text, name) {
+    // Drop a leading/space-padded {{name}} cleanly when no name is known.
+    if (!name)
+        return text.replace(/,?\s*\{\{name\}\}/g, '').replace(/\{\{name\}\}/g, '').replace(/\s{2,}/g, ' ').trim();
+    return text.replace(/\{\{name\}\}/g, name);
+}
+const HINT_STOP = new Set([
+    'recemment',
+    'parle',
+    'parler',
+    'surtout',
+    'conversation',
+    'dernier',
+    'point',
+    'utilisateur',
+    'position',
+    'episode',
+    'lisa',
+]);
+const ARRIVAL_JARGON = /<[^>]+>|\/100|\blisa_state\b|\brecent_episode\b|\buser_model\b|\bTraits dominants\b|\bRegistre expressif\b|\bj['’]ai appris à/i;
+const FACT_HINT = /\b(train|souvenir|demain|concert|anniversaire|valise|rendez[- ]vous)\b/i;
+/** Spoken recap of the day without XML, scores, or prompt scaffolding. */
+export function spokenEpisodeHint(episodeLine) {
+    const cleaned = episodeLine.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    if (!cleaned)
+        return '';
+    const segments = cleaned.split(/\s*;\s*/);
+    const factSegs = segments.filter((segment) => FACT_HINT.test(segment));
+    const pool = factSegs.length > 0 ? factSegs : segments;
+    const terms = extractSalientTerms(pool.join(' '), 8).filter((term) => !HINT_STOP.has(term));
+    if (terms.length === 0)
+        return '';
+    return `Tout à l'heure, on parlait de ${terms.slice(0, 4).join(', ')}.`;
+}
+export function isJargonArrivalLine(text) {
+    return ARRIVAL_JARGON.test(text);
+}
+/**
+ * Build a varied, context-aware arrival opener. Picks a trigger from time/gap/state, then a template
+ * from that trigger's pool avoiding `recent` (falls back to the full pool if all were used recently).
+ */
+export function buildArrivalOpener(ctx) {
+    const rng = ctx.rng ?? Math.random;
+    const recent = ctx.recent ?? [];
+    const trigger = selectTrigger(ctx);
+    const pool = templatePool(trigger);
+    const fresh = pool.filter((t) => !recent.includes(t)); // recent holds RAW templates
+    // When the whole pool was used recently, still avoid the SINGLE most-recent
+    // line so it's never the exact same phrase twice in a row (the core complaint).
+    let choices = fresh.length > 0 ? fresh : pool.filter((t) => t !== recent[0]);
+    if (choices.length === 0)
+        choices = [...pool]; // pool of one — nothing else to pick
+    const idx = Math.min(choices.length - 1, Math.floor(rng() * choices.length));
+    const template = choices[idx];
+    const safeName = ctx.recognizedUser === false ? undefined : ctx.name;
+    let text = interpolate(template, safeName);
+    if ((trigger === 'evening' || trigger === 'afternoon') && ctx.episodeLine) {
+        const hint = spokenEpisodeHint(ctx.episodeLine);
+        if (hint && !isJargonArrivalLine(hint)) {
+            text = `${text} ${hint}`.replace(/\s+/g, ' ').trim();
+        }
+    }
+    return { text, trigger, template };
+}
+/** Pure identity gate used by the semantic camera reaction before naming an arrival. */
+export function isConfiguredUserIdentity(identityName, configuredName = process.env.CODEBUDDY_USER_NAME) {
+    const identity = identityName.trim().toLocaleLowerCase();
+    const configured = configuredName?.trim().toLocaleLowerCase() ?? '';
+    return Boolean(identity && configured && identity === configured);
+}
+// ---- Optional LLM opener (layered on top for real, non-scripted freshness) -------------------
+const TRIGGER_TIME_LABEL = {
+    morning: 'le matin',
+    afternoon: 'l’après-midi',
+    evening: 'le soir',
+    night: 'tard, la nuit',
+    backSoon: 'il vient juste de revenir (parti quelques minutes)',
+    drowsy: 'il a l’air fatigué',
+};
+/** Default chat: route to the sensory voice model (same path as hybrid-reply / respond-decider). */
+async function defaultVoiceChat(messages) {
+    try {
+        const { resolveVoiceModel } = await import('./voice-loop.js');
+        const { CodeBuddyClient } = await import('../codebuddy/client.js');
+        const route = await resolveVoiceModel('');
+        const client = new CodeBuddyClient(route.apiKey, route.model, route.baseURL);
+        const resp = (await client.chat(messages, []));
+        return (resp?.choices?.[0]?.message?.content ?? '').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate a fresh, context-aware arrival line with the voice LLM — the natural,
+ * non-scripted layer on top of the deterministic templates. Seeds the model with
+ * the time context, the recent lines to AVOID, and (optionally) the last things
+ * heard so it can reference the conversation. Returns a single clean line, or
+ * `null` on timeout / error / unavailable → the caller falls back to the instant
+ * deterministic opener. Never throws.
+ */
+export async function buildLlmArrivalOpener(ctx) {
+    const chat = ctx.chat ?? defaultVoiceChat;
+    const timeoutMs = ctx.timeoutMs ?? Number(process.env.CODEBUDDY_SENSORY_GREET_LLM_TIMEOUT_MS ?? 4000);
+    const trigger = selectTrigger({ now: ctx.now, lastSeenAt: ctx.lastSeenAt, drowsy: ctx.drowsy });
+    const who = ctx.name || 'la personne';
+    const avoid = (ctx.recentTexts ?? []).filter(Boolean).slice(0, 6);
+    const heard = (ctx.recentHeard ?? []).filter(Boolean).slice(0, 4);
+    const sys = [
+        ctx.personaPrompt?.trim() || 'Tu es un compagnon robot chaleureux, tendre et attentionné.',
+        `Tu viens de voir ${who} apparaître devant ta caméra. Dis UNE seule phrase d'accueil — courte, naturelle, chaleureuse et VARIÉE, comme un vrai compagnon (pas un assistant). Pas forcément une question.`,
+        `Moment : ${TRIGGER_TIME_LABEL[trigger]}.`,
+        ctx.relationalContext?.trim() ? `Ce que tu sais de lui et ton registre expressif (utilise-le en douceur, sans réciter ni prétendre éprouver des émotions humaines) :\n${ctx.relationalContext.trim()}` : '',
+        (() => {
+            const hint = ctx.episodeLine?.trim() ? spokenEpisodeHint(ctx.episodeLine) : '';
+            return hint
+                ? `Ce dont vous avez parlé récemment (évoque-le en douceur, sans balises XML, sans scores /100, sans notes d'évolution) : ${hint}`
+                : '';
+        })(),
+        heard.length ? `Dernières choses qu'il t'a dites (tu peux y faire référence en douceur, sans forcer) : ${heard.map((h) => `« ${h} »`).join(' ; ')}.` : '',
+        avoid.length ? `N'utilise PAS ces formulations récentes : ${avoid.map((a) => `« ${a} »`).join(' ; ')}.` : '',
+        `Réponds en français, UNE phrase, sans guillemets, sans emoji superflu, sans préambule.`,
+        `N'utilise jamais de balises XML, de scores /100, ni de notes d'évolution internes. Ne mentionne pas ce qui a changé chez toi sauf si on te le demande explicitement.`,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    try {
+        const raw = await withTimeout(chat([
+            { role: 'system', content: sys },
+            { role: 'user', content: "Ta phrase d'accueil :" },
+        ]), timeoutMs, 'arrival-opener');
+        if (!raw)
+            return null;
+        const line = raw.split('\n').map((s) => s.trim()).find(Boolean) ?? '';
+        const cleaned = line.replace(/^["“«]\s*/, '').replace(/\s*["”»]$/, '').trim();
+        if (cleaned.length < 2)
+            return null;
+        const guarded = guardRelationshipReply(cleaned);
+        // Null selects the reviewed deterministic opener; a generic policy repair
+        // would sound unnatural as an arrival greeting.
+        if (guarded.intervened)
+            return null;
+        if (isJargonArrivalLine(guarded.response))
+            return null;
+        return guarded.response;
+    }
+    catch {
+        return null;
+    }
+}
+export const ARRIVAL_RING_SIZE = 10;
+function defaultStatePath() {
+    return join(homedir(), '.codebuddy', 'companion', 'arrival-state.json');
+}
+export function loadArrivalState(statePath = defaultStatePath()) {
+    const data = readJsonAtomicSync(statePath, null, {
+        mode: 0o600,
+        isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+    });
+    if (!data)
+        return { recent: [] };
+    return {
+        recent: Array.isArray(data.recent) ? data.recent.filter((item) => typeof item === 'string') : [],
+        ...(typeof data.lastSeenAt === 'number' ? { lastSeenAt: data.lastSeenAt } : {}),
+        ...(Array.isArray(data.recentSpoken)
+            ? { recentSpoken: data.recentSpoken.filter((item) => typeof item === 'string') }
+            : {}),
+    };
+}
+export function saveArrivalState(state, statePath = defaultStatePath()) {
+    try {
+        writeJsonAtomicSync(statePath, state, { mode: 0o600 });
+    }
+    catch {
+        /* best effort */
+    }
+}
+/** Push a used template onto the recent ring (most-recent first, capped). */
+export function pushRecent(recent, template) {
+    return [template, ...recent.filter((t) => t !== template)].slice(0, ARRIVAL_RING_SIZE);
+}
+//# sourceMappingURL=arrival-opener.js.map

package/dist/sensory/audio-scene.d.ts

@@ -0,0 +1,24 @@
+/** Cheap, deterministic and raw-free acoustic scene interpretation. */
+import type { VoiceSceneClass } from './voice-turn-coordinator.js';
+export interface AudioSceneInput {
+    /** Used transiently for metrics only; never returned or persisted. */
+    transcript?: string;
+    decisionReason?: string;
+    playbackCaptureKind?: 'during_playback' | 'echo_tail';
+    echoClassification?: 'echo' | 'distinct' | 'unknown';
+    rms?: number;
+    rmsOn?: number;
+    audioMs?: number;
+    turnDetector?: string;
+    speakerCount?: number;
+    aecActive?: boolean;
+}
+export interface AudioSceneAssessment {
+    scene: VoiceSceneClass;
+    confidence: number;
+    evidence: string[];
+    wordCount: number;
+    speechMs?: number;
+    aecActive: boolean;
+}
+export declare function assessAudioScene(input: AudioSceneInput): AudioSceneAssessment;

package/dist/sensory/audio-scene.js

@@ -0,0 +1,74 @@
+/** Cheap, deterministic and raw-free acoustic scene interpretation. */
+const DIRECT_REASONS = new Set([
+    'addressed',
+    'engaged',
+    'greeting',
+    'directed-request',
+    'conversation-close',
+]);
+const BROADCAST_REASONS = new Set([
+    'ambient',
+    'ambient-long',
+    'ambient-burst',
+    'ambient-in-window',
+    'no-cue',
+    'not-warranted',
+]);
+function words(text) {
+    return text?.match(/[\p{L}\p{N}]+/gu)?.length ?? 0;
+}
+function confidence(value) {
+    return Math.round(Math.max(0, Math.min(1, value)) * 1000) / 1000;
+}
+export function assessAudioScene(input) {
+    const wordCount = words(input.transcript);
+    const evidence = [];
+    const base = {
+        wordCount,
+        ...(Number.isFinite(input.audioMs) && (input.audioMs ?? 0) >= 0
+            ? { speechMs: Math.round(input.audioMs) }
+            : {}),
+        aecActive: input.aecActive === true,
+    };
+    if (input.playbackCaptureKind) {
+        evidence.push(input.playbackCaptureKind);
+        if (input.echoClassification)
+            evidence.push(`echo_${input.echoClassification}`);
+        return {
+            scene: 'assistant_playback',
+            confidence: confidence(input.echoClassification === 'echo' ? 0.99 : 0.82),
+            evidence,
+            ...base,
+        };
+    }
+    if (input.decisionReason && DIRECT_REASONS.has(input.decisionReason)) {
+        evidence.push(`decision_${input.decisionReason}`);
+        if (input.turnDetector)
+            evidence.push('semantic_turn_detector');
+        return { scene: 'near_speech', confidence: confidence(0.9), evidence, ...base };
+    }
+    if ((input.speakerCount ?? 0) > 1) {
+        evidence.push('multiple_speakers');
+        return { scene: 'broadcast', confidence: confidence(0.84), evidence, ...base };
+    }
+    if (input.decisionReason && BROADCAST_REASONS.has(input.decisionReason)) {
+        evidence.push(`decision_${input.decisionReason}`);
+        if (wordCount > 16)
+            evidence.push('long_utterance');
+        return {
+            scene: 'broadcast',
+            confidence: confidence(wordCount > 16 ? 0.88 : 0.72),
+            evidence,
+            ...base,
+        };
+    }
+    const belowGate = Number.isFinite(input.rms)
+        && Number.isFinite(input.rmsOn)
+        && input.rms < input.rmsOn;
+    if (wordCount <= 1 && belowGate) {
+        evidence.push('below_adaptive_gate');
+        return { scene: 'noise', confidence: confidence(0.8), evidence, ...base };
+    }
+    return { scene: 'unknown', confidence: confidence(0.35), evidence, ...base };
+}
+//# sourceMappingURL=audio-scene.js.map

package/dist/sensory/camera-keyframe-policy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolve an untrusted sensor path inside the configured camera spool.
+ * Returning the real path prevents traversal and symlink escapes before a VLM
+ * or Telegram adapter reads the file.
+ */
+export declare function safeCameraKeyframePath(candidate: unknown, options?: {
+    root?: string;
+    maxBytes?: number;
+}): Promise<string | undefined>;
+/** Raw camera egress is a separate consent from semantic vision processing. */
+export declare function telegramVisionPhotoPath(path: string | undefined): string | undefined;