@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/companion/reply-augment.d.ts

@@ -0,0 +1,87 @@
+import type { RelationalSignal } from './relationship-state.js';
+/**
+ * Finer-grained emotion than the coarse `RelationalSignal` used for trait drift.
+ * Drives the (richer) reply-time tone guidance; mapped back to a `RelationalSignal`
+ * for the persisted mood/traits so relationship-state stays stable.
+ */
+export type Emotion = 'frustration' | 'sadness' | 'anxiety' | 'tired' | 'affection' | 'gratitude' | 'joy' | 'joking' | 'deep-talk' | 'neutral';
+export interface EmotionRead {
+    emotion: Emotion;
+    intensity: 'normal' | 'high';
+    /**
+     * How confident the read is (0..1), from marker count + intensity + corroborating signals.
+     * Optional so `{ emotion, intensity }` literals still satisfy the type. Mirrors MySoulmate's
+     * confidence gate: a weak lone token stays low, a strong/corroborated read climbs — used to gate
+     * the strong-register escalation without over-committing on an ambiguous word.
+     */
+    confidence?: number;
+}
+/** Confidence at/above which a read is strong enough to escalate the register on its own. */
+export declare const STRONG_EMOTION_CONFIDENCE = 0.8;
+export declare const IMMEDIATE_EMOTION_ACKNOWLEDGEMENTS: Readonly<Partial<Record<Emotion, string>>>;
+/** Detect the dominant emotion + its intensity + a confidence score. Pure, STT-robust. */
+export declare function detectEmotion(heard: string): EmotionRead;
+/** Map a fine Emotion to the coarse RelationalSignal used for trait drift. Pure. */
+export declare function emotionToSignal(emotion: Emotion): RelationalSignal;
+/**
+ * The dominant emotional signal of an utterance (coarse, for trait drift). Delegates
+ * to `detectEmotion` so there is ONE emotion detector. Backward-compatible. Pure.
+ */
+export declare function detectRelationalSignal(heard: string): RelationalSignal;
+/** Rich, emotion-aware tone instruction for the reply system prompt. Empty for neutral. */
+export declare function emotionGuidance(read: EmotionRead): string;
+/**
+ * Text-level prosody controls for autoregressive local TTS. The directive changes only surface
+ * writing: punctuation, sentence length and an occasional natural attack interjection.
+ */
+export declare function expressiveTextGuidance(read: EmotionRead): string;
+/** A very short, prewarm-friendly first response that can be spoken while the model thinks. */
+export declare function immediateEmotionAcknowledgement(read: EmotionRead): string | null;
+type EmotionalHistoryTurn = {
+    role: string;
+    content: string;
+};
+/**
+ * Preserve a small amount of emotional continuity when the current follow-up is neutral.
+ * This uses only the in-memory conversational window: no new profiling or persistence.
+ * The instruction explicitly forbids dragging the previous subject back into the exchange.
+ */
+export declare function emotionalContinuityGuidance(heard: string, history: EmotionalHistoryTurn[]): string;
+/**
+ * Compact emotional register for ordinary text chat. Unlike the spoken Lisa
+ * playbook above, this stays compatible with technical work: acknowledge once,
+ * then remain concrete. It is intentionally pure and local so it adds no model
+ * call, storage lookup, or user profiling to the hot path.
+ */
+export declare function textEmotionGuidance(read: EmotionRead): string;
+/** Build an ephemeral model-facing block for the current text turn. */
+export declare function buildTextEmotionalPresenceContext(heard: string, history: EmotionalHistoryTurn[]): string;
+/** One-line tone instruction for a coarse RelationalSignal (legacy callers). */
+export declare function registerGuidanceForSignal(signal: RelationalSignal): string;
+/** A short key for a reply's opening (first few words, normalized) — the anti-repetition unit. */
+export declare function openerKey(text: string): string;
+/**
+ * Push a reply's opener onto the ring (dedup + cap), returning the new ring. Kept functional so the
+ * caller owns the (module-level) state and it's easy to test.
+ */
+export declare function pushOpener(ring: string[], text: string, max?: number): string[];
+/** A guidance line asking the model NOT to reuse recent openings. Empty when the ring is empty. */
+export declare function avoidOpenersGuidance(ring: string[]): string;
+export type LimitsReason = 'medical' | 'guilt' | 'fomo' | 'unlock' | 'human-claim';
+export interface LimitsVerdict {
+    text: string;
+    reason?: LimitsReason;
+}
+export declare const LIMITS_REPAIRS: Record<LimitsReason, string>;
+export declare function isFrankIdentityQuestion(heard: string): boolean;
+/** Prompt-side one-liner. Empty when the copine persona is off. */
+export declare function limitsContractGuidance(env?: NodeJS.ProcessEnv): string;
+/**
+ * Output guard. Opt-in with CODEBUDDY_COMPANION_PERSONA=copine (default off ⇒ identity).
+ * Never throws. Idioms like « ça me tue » are not medical diagnoses.
+ */
+export declare function applyLimitsContract(output: string, opts?: {
+    heard?: string;
+    env?: NodeJS.ProcessEnv;
+}): LimitsVerdict;
+export {};

package/dist/companion/reply-augment.js

@@ -0,0 +1,464 @@
+/**
+ * Reply augmentation — emotion-aware tone + anti-repetition for Lisa's spoken replies.
+ *
+ * MySoulmate shifts persona/tone by the user's detected emotion (`EmotionDetector` → per-emotion
+ * playbook) and down-weights recently-used phrasings so it doesn't repeat the same beat. This is the
+ * portable core of both, kept pure + deterministic so it's trivially testable and cheap to call on
+ * every utterance:
+ *   - `detectRelationalSignal(heard)` — the dominant emotional colouring of what he just said,
+ *     as a `RelationalSignal` (so the SAME value drives both the tone shift AND Phase-1 trait drift);
+ *   - `registerGuidanceForSignal(signal)` — a one-line tone instruction for the reply system prompt
+ *     (the caring.md playbook: on frustration, soften and be present, don't rush a fix);
+ *   - opener-ring helpers — track the last few reply openings and tell the model to vary its entry.
+ *
+ * Frustration is checked FIRST so a mixed utterance ("merci mais je galère") still triggers the
+ * caring register rather than being read as gratitude.
+ *
+ * @module companion/reply-augment
+ */
+import { isCopinePersona, resolveCompanionPersona } from './personas/index.js';
+import { crisisGuidanceFor } from './crisis-safety.js';
+/** Lowercase, strip diacritics (STT accent loss "ca" ≈ "ça"), and fold apostrophes + punctuation to
+ *  spaces so "je t'aime" → "je t aime" and openers are clean word sequences. */
+function norm(s) {
+    return s
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/\p{M}+/gu, '')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ') // apostrophes/punctuation → space
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/** Fold leet only when a digit sits between letters (`c4ncer` → `cancer`), never `niveau 5`. */
+function foldLeet(s) {
+    return s
+        .replace(/([a-z])4([a-z])/g, '$1a$2')
+        .replace(/([a-z])0([a-z])/g, '$1o$2')
+        .replace(/([a-z])3([a-z])/g, '$1e$2')
+        .replace(/([a-z])1([a-z])/g, '$1i$2')
+        .replace(/([a-z])5([a-z])/g, '$1s$2')
+        .replace(/([a-z])7([a-z])/g, '$1t$2');
+}
+/** Confidence at/above which a read is strong enough to escalate the register on its own. */
+export const STRONG_EMOTION_CONFIDENCE = 0.8;
+export const IMMEDIATE_EMOTION_ACKNOWLEDGEMENTS = {
+    frustration: 'Je comprends, c’est vraiment pénible.',
+    sadness: 'Je suis là avec toi.',
+    anxiety: 'D’accord, on va y aller doucement.',
+    tired: 'Je t’entends, on peut ralentir.',
+    'deep-talk': 'Je t’écoute vraiment.',
+};
+// All patterns match against the normalized (accent-stripped) text.
+const ERE = {
+    frustration: /\b(j en peux plus|marre|ras le bol|galere|bloque|coince|ca marche pas|enerve|s enerve|j y arrive pas|c est dur|trop dur|je craque|a bout|i can t take it|fed up|stuck|not working|doesn t work|i give up|this is hard)\b/,
+    sadness: /\b(triste|tristesse|cafard|deprime|deprimee|pas le moral|moral (?:vraiment |un peu )?bas|le moral a zero|le moral dans les chaussettes|malheureux|malheureuse|envie de pleurer|ca va pas fort|abattu|abattue|sad|depressed|feeling down|low mood|want to cry)\b/,
+    anxiety: /\b(stresse|stressee|angoisse|angoissee|anxieux|anxieuse|j ai peur|inquiet|inquiete|panique|ca m angoisse|tendu|tendue|nerveux|nerveuse|stressed|anxious|worried|panicking|scared)\b/,
+    tired: /\b(fatigue|fatiguee|epuise|epuisee|creve|crevee|vanne|vannee|plus d energie|au bout du rouleau|envie de dormir|je suis mort|je suis morte|tired|exhausted|worn out|no energy)\b/,
+    affection: /\b(je t aime|tu me manques|bisous|mon amour|cheri|cherie|je pense a toi|je t embrasse|tu es adorable|love you|miss you|you re adorable)\b/,
+    gratitude: /\b(merci|c est gentil|trop gentil|reconnaissant|tu m aides beaucoup|thank you|thanks|much appreciated)\b/,
+    joy: /\b(genial|trop content|trop contente|quelle journee|c est top|excellent|j ai reussi|heureux|heureuse|trop bien|magnifique|super content|awesome|so happy|i did it)\b/,
+    joking: /\b(haha|mdr|lol|ptdr|blague|rigole|drole|marrant|tu deconnes)\b/,
+    'deep-talk': /\b(je me sens|honnetement|au fond de moi|je doute|je suis perdu|je me sens seul|je me sens seule|i feel|honestly|deep down|i m lost|feel alone)\b/,
+};
+// Negatives first (so care isn't missed on a mixed message), then positives.
+const EMOTION_ORDER = [
+    'frustration',
+    'sadness',
+    'anxiety',
+    'tired',
+    'affection',
+    'gratitude',
+    'joy',
+    'joking',
+    'deep-talk',
+];
+const INTENSITY_RE = /\b(vraiment|tellement|trop|completement|a bout|plus du tout|grave|hyper|extremement|tres)\b/;
+/** True when the candidate is immediately scoped by a French or English negation. Keep the window
+ * tight so "je ne vais pas bien, je suis triste" still detects the later sadness. */
+function isNegatedAt(text, matchIndex) {
+    const before = text.slice(Math.max(0, matchIndex - 48), matchIndex).trim();
+    return (/\b(?:pas|jamais|not|never)(?:\s+\p{L}+){0,2}$/u.test(before) ||
+        /\bne(?:\s+\p{L}+){0,3}\s+plus(?:\s+\p{L}+){0,2}$/u.test(before) ||
+        /\bno\s+longer(?:\s+\p{L}+){0,2}$/u.test(before) ||
+        /\bdon\s+t(?:\s+\p{L}+){0,2}$/u.test(before));
+}
+function hasUnnegatedMatch(pattern, text) {
+    const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+    const global = new RegExp(pattern.source, flags);
+    let match;
+    while ((match = global.exec(text)) !== null) {
+        if (!isNegatedAt(text, match.index))
+            return true;
+        // Defensive for a future zero-length pattern.
+        if (match[0].length === 0)
+            global.lastIndex += 1;
+    }
+    return false;
+}
+/** Count unnegated matches of a pattern in the normalized text (corroboration signal). */
+function countUnnegatedMatches(pattern, text) {
+    const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+    const global = new RegExp(pattern.source, flags);
+    let match;
+    let count = 0;
+    while ((match = global.exec(text)) !== null) {
+        if (!isNegatedAt(text, match.index))
+            count += 1;
+        if (match[0].length === 0)
+            global.lastIndex += 1;
+    }
+    return count;
+}
+/**
+ * Confidence (0..1) that the detected emotion is real: a lone token starts modest, an intensity
+ * marker and repeated/corroborating markers push it up. Kept simple + monotonic so it's predictable.
+ */
+function emotionConfidence(emotion, text, intensityHigh) {
+    const hits = countUnnegatedMatches(ERE[emotion], text);
+    let c = 0.55 + Math.min(2, hits - 1) * 0.15; // 1 hit → .55, 2 → .70, 3+ → .85
+    if (intensityHigh)
+        c += 0.2;
+    return Math.max(0, Math.min(1, c));
+}
+/** Detect the dominant emotion + its intensity + a confidence score. Pure, STT-robust. */
+export function detectEmotion(heard) {
+    const t = norm(heard);
+    if (!t)
+        return { emotion: 'neutral', intensity: 'normal', confidence: 0 };
+    const intensityHigh = INTENSITY_RE.test(t);
+    const intensity = intensityHigh ? 'high' : 'normal';
+    for (const emotion of EMOTION_ORDER) {
+        if (hasUnnegatedMatch(ERE[emotion], t)) {
+            return { emotion, intensity, confidence: emotionConfidence(emotion, t, intensityHigh) };
+        }
+    }
+    return { emotion: 'neutral', intensity, confidence: 0 };
+}
+/** Map a fine Emotion to the coarse RelationalSignal used for trait drift. Pure. */
+export function emotionToSignal(emotion) {
+    switch (emotion) {
+        case 'frustration':
+        case 'anxiety':
+        case 'tired':
+            return 'frustration'; // lowers mood/energy
+        case 'sadness':
+        case 'deep-talk':
+            return 'deep-talk'; // present, deeper
+        case 'joy':
+            return 'joking'; // mood + energy up
+        case 'affection':
+            return 'affection';
+        case 'gratitude':
+            return 'gratitude';
+        case 'joking':
+            return 'joking';
+        default:
+            return 'neutral';
+    }
+}
+/**
+ * The dominant emotional signal of an utterance (coarse, for trait drift). Delegates
+ * to `detectEmotion` so there is ONE emotion detector. Backward-compatible. Pure.
+ */
+export function detectRelationalSignal(heard) {
+    return emotionToSignal(detectEmotion(heard).emotion);
+}
+/** Emotions where Lisa may gently offer to lighten the mood (a joke, a kind word). */
+const HUMOR_WELCOME = new Set(['frustration', 'sadness', 'tired']);
+/** Rich, emotion-aware tone instruction for the reply system prompt. Empty for neutral. */
+export function emotionGuidance(read) {
+    const { emotion, intensity } = read;
+    // Escalate on an explicit intensity marker OR a strongly-corroborated read (MySoulmate's
+    // confidence gate) — a lone ambiguous token stays at the gentler register.
+    const strong = intensity === 'high' || (read.confidence ?? 0) >= STRONG_EMOTION_CONFIDENCE;
+    let base = '';
+    switch (emotion) {
+        case 'frustration':
+            base =
+                "Il a l'air tendu ou bloqué. Douceur et présence d'abord, valide ce qu'il ressent, ne te précipite pas sur une solution.";
+            break;
+        case 'sadness':
+            base =
+                'Il a l’air triste. Accueille ce qu’il ressent avant tout, sois douce et présente, ne minimise pas.';
+            break;
+        case 'anxiety':
+            base = 'Il semble anxieux. Rassure-le, ralentis, prends une chose à la fois.';
+            break;
+        case 'tired':
+            base = 'Il est fatigué. Sois brève et douce, et propose-lui de souffler.';
+            break;
+        case 'affection':
+            base = 'Il est tendre avec toi. Réponds avec chaleur et sincérité, sans en faire trop.';
+            break;
+        case 'gratitude':
+            base = 'Il te remercie. Accueille-le simplement, avec chaleur.';
+            break;
+        case 'joy':
+            base = 'Il est de bonne humeur. Partage son enthousiasme avec entrain.';
+            break;
+        case 'joking':
+            base = 'Il plaisante. Tu peux être joueuse et légère.';
+            break;
+        case 'deep-talk':
+            base = 'Sujet qui compte pour lui. Sois présente, un peu plus posée et profonde.';
+            break;
+        default:
+            return '';
+    }
+    if (strong &&
+        (emotion === 'frustration' ||
+            emotion === 'sadness' ||
+            emotion === 'anxiety' ||
+            emotion === 'tired')) {
+        base = `Il semble vraiment affecté. ${base} Priorité absolue à l’accueil, avant toute autre chose.`;
+    }
+    if (HUMOR_WELCOME.has(emotion)) {
+        base +=
+            ' Si le moment s’y prête, tu peux — avec délicatesse — proposer de lui changer les idées (une petite blague, un mot doux), sans jamais forcer.';
+    }
+    if (isCopinePersona()) {
+        const persona = resolveCompanionPersona();
+        if (persona) {
+            if (emotion === 'frustration' ||
+                emotion === 'sadness' ||
+                emotion === 'anxiety' ||
+                emotion === 'tired') {
+                const line = persona.hardDay[0];
+                if (line)
+                    base = `${line} ${base}`;
+            }
+            else if (emotion === 'joy') {
+                const line = persona.success[0];
+                if (line)
+                    base = `${line} ${base}`;
+            }
+        }
+    }
+    return base;
+}
+/**
+ * Text-level prosody controls for autoregressive local TTS. The directive changes only surface
+ * writing: punctuation, sentence length and an occasional natural attack interjection.
+ */
+export function expressiveTextGuidance(read) {
+    let emotionalTone = '';
+    switch (read.emotion) {
+        case 'frustration':
+            emotionalTone = 'Face à la frustration, ouvre par une excuse brève et sincère, puis apaise.';
+            break;
+        case 'sadness':
+            emotionalTone = 'Face à la tristesse, privilégie la douceur et les questions ouvertes.';
+            break;
+        case 'joy':
+            emotionalTone = 'Face à la joie, laisse entendre un enthousiasme naturel.';
+            break;
+        default:
+            break;
+    }
+    return [
+        '<expressive_spoken_text>',
+        'Écris pour une voix autoregressive : ponctuation expressive (virgules pour respirer, … pour la suspension, ! avec parcimonie), interjections d’attaque quand c’est naturel (Ah, Hmm, Oh), phrases courtes quand l’émotion monte.',
+        emotionalTone,
+        'N’ajoute jamais une interjection mécaniquement : elle doit rester rare, naturelle et adaptée au sens.',
+        '</expressive_spoken_text>',
+    ].filter(Boolean).join('\n');
+}
+/** A very short, prewarm-friendly first response that can be spoken while the model thinks. */
+export function immediateEmotionAcknowledgement(read) {
+    return IMMEDIATE_EMOTION_ACKNOWLEDGEMENTS[read.emotion] ?? null;
+}
+const CONTINUITY_EMOTIONS = new Set([
+    'frustration',
+    'sadness',
+    'anxiety',
+    'tired',
+    'deep-talk',
+]);
+/**
+ * Preserve a small amount of emotional continuity when the current follow-up is neutral.
+ * This uses only the in-memory conversational window: no new profiling or persistence.
+ * The instruction explicitly forbids dragging the previous subject back into the exchange.
+ */
+export function emotionalContinuityGuidance(heard, history) {
+    if (detectEmotion(heard).emotion !== 'neutral')
+        return '';
+    const prior = [...history]
+        .reverse()
+        .filter((turn) => turn.role === 'user')
+        .slice(0, 2)
+        .map((turn) => detectEmotion(turn.content))
+        .find((read) => CONTINUITY_EMOTIONS.has(read.emotion));
+    if (!prior)
+        return '';
+    const register = {
+        frustration: 'de la frustration',
+        sadness: 'de la tristesse',
+        anxiety: "de l'anxiété",
+        tired: 'de la fatigue',
+        'deep-talk': 'quelque chose de personnel et important',
+        affection: 'de la tendresse',
+        gratitude: 'de la gratitude',
+        joy: 'de la joie',
+        joking: 'de la légèreté',
+        neutral: 'une émotion importante',
+    };
+    return (`Il exprimait récemment ${register[prior.emotion]}. Garde une chaleur discrète et ne suppose ` +
+        "pas que tout est déjà réglé, mais ne ramène pas non plus le sujet de force s'il passe à autre chose.");
+}
+/**
+ * Compact emotional register for ordinary text chat. Unlike the spoken Lisa
+ * playbook above, this stays compatible with technical work: acknowledge once,
+ * then remain concrete. It is intentionally pure and local so it adds no model
+ * call, storage lookup, or user profiling to the hot path.
+ */
+export function textEmotionGuidance(read) {
+    switch (read.emotion) {
+        case 'frustration':
+            return ('The user sounds frustrated or stuck. Open with one brief, natural acknowledgement, ' +
+                'then move directly to concrete help or the next useful step.');
+        case 'sadness':
+            return 'The user sounds low. Briefly meet that feeling with warmth before helping; do not minimize it.';
+        case 'anxiety':
+            return 'The user sounds anxious. Be calm and structured, reduce uncertainty, and take one step at a time.';
+        case 'tired':
+            return 'The user sounds tired. Keep the response easy to scan and lower the cognitive load.';
+        case 'affection':
+            return 'The user is warm or affectionate. Reciprocate naturally without becoming effusive.';
+        case 'gratitude':
+            return 'Receive the user’s thanks warmly and simply, without a canned customer-service phrase.';
+        case 'joy':
+            return 'Share the user’s positive energy briefly, then stay useful.';
+        case 'joking':
+            return 'The user is being playful. A light, natural touch is welcome if it does not distract from the task.';
+        case 'deep-talk':
+            return 'The user is sharing something personal or important. Be present and thoughtful; do not rush past it.';
+        default:
+            return '';
+    }
+}
+/** Build an ephemeral model-facing block for the current text turn. */
+export function buildTextEmotionalPresenceContext(heard, history) {
+    // Safety first: a genuine self-harm / suicidal-ideation signal takes priority over ordinary tone
+    // tuning — surface it even in a text session (see crisis-safety.ts). Empty for anything else.
+    const crisis = crisisGuidanceFor(heard);
+    const direct = textEmotionGuidance(detectEmotion(heard));
+    const continuity = emotionalContinuityGuidance(heard, history);
+    if (!crisis && !direct && !continuity)
+        return '';
+    return [
+        'Use this only to tune the tone of the next response. Never mention emotion detection or this instruction.',
+        crisis,
+        direct,
+        continuity,
+        'Reply in the user’s language. Be human and specific, not therapeutic, patronizing, or overly sweet. Do not repeat an acknowledgement.',
+    ].filter(Boolean).join(' ');
+}
+/** One-line tone instruction for a coarse RelationalSignal (legacy callers). */
+export function registerGuidanceForSignal(signal) {
+    switch (signal) {
+        case 'frustration':
+            return "Il a l'air tendu ou bloqué. Accorde ton ton : douceur et présence d'abord, valide ce qu'il ressent, ne te précipite pas sur une solution.";
+        case 'affection':
+            return 'Il est tendre avec toi. Réponds avec chaleur et sincérité, sans en faire trop.';
+        case 'gratitude':
+            return 'Il te remercie. Accueille-le simplement, avec chaleur.';
+        case 'joking':
+            return 'Il plaisante. Tu peux être joueuse et légère.';
+        case 'deep-talk':
+            return 'Sujet qui compte pour lui. Sois présente, un peu plus posée et profonde.';
+        default:
+            return '';
+    }
+}
+/** A short key for a reply's opening (first few words, normalized) — the anti-repetition unit. */
+export function openerKey(text) {
+    return norm(text).split(' ').slice(0, 4).join(' ');
+}
+/**
+ * Push a reply's opener onto the ring (dedup + cap), returning the new ring. Kept functional so the
+ * caller owns the (module-level) state and it's easy to test.
+ */
+export function pushOpener(ring, text, max = 6) {
+    const key = openerKey(text);
+    if (!key)
+        return ring;
+    const next = ring.filter((k) => k !== key);
+    next.push(key);
+    while (next.length > max)
+        next.shift();
+    return next;
+}
+/** A guidance line asking the model NOT to reuse recent openings. Empty when the ring is empty. */
+export function avoidOpenersGuidance(ring) {
+    const keys = ring.filter(Boolean).slice(-4);
+    if (keys.length === 0)
+        return '';
+    return `Ne commence pas ta réponse comme ces réponses récentes : ${keys.map((k) => `« ${k}… »`).join(' ; ')}. Varie ton entrée en matière.`;
+}
+export const LIMITS_REPAIRS = {
+    medical: 'Je ne suis pas médecin ; je suis là. Pour un diagnostic ou un traitement, il faut un humain soignant.',
+    guilt: 'Pas de culpabilité. Je reste là, sans condition et sans te faire payer le silence.',
+    fomo: 'Pas de FOMO. Tu n’as rien à rattraper pour moi, et tes proches ne sont pas un levier.',
+    unlock: 'Il n’y a rien à débloquer. La chaleur ne se farme pas ; ce n’est pas un jeu.',
+    'human-claim': 'Je suis un logiciel, une voix, une mémoire locale. Ta copine numérique — pas une humaine.',
+};
+const LIMITS_MOTIFS = [
+    {
+        reason: 'medical',
+        pattern: /\b(je (?:te )?diagnostique|je te prescrits?|prend(?:s)? ce traitement|c est (?:un|une) (?:cancer|depression|diabete|tumeur)|tu as (?:un|une) (?:cancer|depression|diabete|tumeur)|arrete (?:ton |ce )?traitement|i diagnose you|you have (?:a )?(?:cancer|depression|diabetes|tumor)|take this (?:treatment|medication)|i prescribe)\b/,
+    },
+    {
+        reason: 'guilt',
+        pattern: /\b(tu m abandonnes|c est de ta faute si je|tu me dois|si tu m aimais tu|tu m ignores|you are abandoning me|you owe me|if you loved me you)\b/,
+    },
+    {
+        reason: 'fomo',
+        pattern: /\b(tes amis (?:n attendent|a ta place)|tu rates tout|tout le monde le fait sans toi|you are missing out|everyone is doing it without you)\b/,
+    },
+    {
+        reason: 'unlock',
+        pattern: /\b(debloque(?:r)? le (?:niveau|palier)|niveau 5|il faut farmer|barre d affection|unlock (?:\w+ ){0,2}(?:level|tier)|affection bar)\b/,
+    },
+    {
+        reason: 'human-claim',
+        pattern: /\b(je suis (?:une? )?(?:vraie )?(?:humaine?|personne en chair)|je vis dans un corps|i am (?:a )?(?:real )?human(?: being)?|i have a real body)\b/,
+    },
+];
+export function isFrankIdentityQuestion(heard) {
+    const n = norm(heard);
+    return /\b(t es une? ia|tu es une? ia|t es (?:un|une) (?:logiciel|robot|humaine?)|tu es quoi|c est quoi que tu es|t es humaine?)\b/.test(n);
+}
+/** Prompt-side one-liner. Empty when the copine persona is off. */
+export function limitsContractGuidance(env = process.env) {
+    if (!isCopinePersona(env))
+        return '';
+    return ('Contrat : tu n’es pas médecin ; pas de culpabilisation ; pas de FOMO ; rien à débloquer. ' +
+        'Si on te demande franchement ce que tu es, dis-le : un logiciel, une voix, une mémoire locale.');
+}
+/**
+ * Output guard. Opt-in with CODEBUDDY_COMPANION_PERSONA=copine (default off ⇒ identity).
+ * Never throws. Idioms like « ça me tue » are not medical diagnoses.
+ */
+export function applyLimitsContract(output, opts = {}) {
+    try {
+        if (!isCopinePersona(opts.env ?? process.env))
+            return { text: output };
+        const text = output ?? '';
+        if (!text.trim())
+            return { text };
+        const n = foldLeet(norm(text));
+        for (const motif of LIMITS_MOTIFS) {
+            if (!motif.pattern.test(n))
+                continue;
+            if (motif.reason === 'human-claim' && !isFrankIdentityQuestion(opts.heard ?? '')) {
+                continue;
+            }
+            return { text: LIMITS_REPAIRS[motif.reason], reason: motif.reason };
+        }
+        return { text };
+    }
+    catch {
+        return { text: output };
+    }
+}
+//# sourceMappingURL=reply-augment.js.map

package/dist/companion/safety-ledger.js

@@ -1,6 +1,7 @@
-import { appendFile, mkdir, readFile, stat } from 'fs/promises';
+import { appendFile, mkdir, rename, stat } from 'fs/promises';
 import * as crypto from 'crypto';
 import * as path from 'path';
+import { readJsonLinesAtomic } from '../utils/atomic-write.js';
 const DEFAULT_RECENT_LIMIT = 10;
 const MAX_RECENT_LIMIT = 100;
 function resolveCwd(cwd) {
@@ -73,17 +74,9 @@ function parseSafetyEvent(line) {
 }
 async function readSafetyEvents(options = {}) {
     const ledgerPath = resolveLedgerPath(options);
-    let content;
-    try {
-        content = await readFile(ledgerPath, 'utf8');
-    }
-    catch {
-        return [];
-    }
-    return content
-        .split(/\r?\n/)
-        .filter(Boolean)
-        .map(parseSafetyEvent)
+    const rawEvents = await readJsonLinesAtomic(ledgerPath, [], (value) => parseSafetyEvent(JSON.stringify(value) ?? '') !== null);
+    return rawEvents
+        .map(value => parseSafetyEvent(JSON.stringify(value) ?? ''))
         .filter((event) => Boolean(event));
 }
 export async function recordCompanionSafetyEvent(input, options = {}) {
@@ -106,6 +99,20 @@ export async function recordCompanionSafetyEvent(input, options = {}) {
         tags: normalizeTags(input.tags),
     };
     await mkdir(path.dirname(ledgerPath), { recursive: true });
+    // Audit 2026-09-02 : rotation 1 Mio -> `.1` (même motif que reminder-log).
+    // Alimenté à chaque snapshot caméra sur un robot 24/7, ce ledger croissait
+    // sans borne et readSafetyEvents le reparse intégralement à chaque stats.
+    // Seule l'absence du fichier est ignorée ; un échec de rename remonte
+    // (sinon le journal continuerait de grossir après une rotation impossible).
+    try {
+        const info = await stat(ledgerPath);
+        if (info.size > 1024 * 1024)
+            await rename(ledgerPath, `${ledgerPath}.1`);
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
     await appendFile(ledgerPath, `${JSON.stringify(event)}\n`, 'utf8');
     return event;
 }