@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/companion/presence-loop.js

@@ -0,0 +1,297 @@
+/**
+ * Presence loop — the companion's "conductor".
+ *
+ * The robot already reacts well (greets, answers, reminds) but had no ambient PRESENCE: a small
+ * warm word at the right moment, otherwise just being there. `check-in.ts` is a mood engine that
+ * was built but never SPOKEN. This loop fires it (and a small library of "moments") on a slow tick
+ * — turning a silent engine into felt company.
+ *
+ * Patrice chose a WARM/present companion, so the cadence is generous — but the rails that prevent
+ * "companion" from curdling into "annoying" are non-negotiable and all tunable:
+ *   - opt-in (`CODEBUDDY_COMPANION_PRESENCE=true`, default OFF)
+ *   - quiet/sleep hours (never speak while you sleep)
+ *   - presence-aware (never to an empty room)
+ *   - not mid human-human conversation
+ *   - an hourly cap + a per-moment cooldown
+ * Otherwise → silent present. Never-throws; everything injectable for deterministic tests.
+ *
+ * @module companion/presence-loop
+ */
+import { logger } from '../utils/logger.js';
+import { loadRelationshipState, saveRelationshipState, daysBetween, pendingMilestone, markMilestonesUpTo, REUNION_DAYS, } from './relationship-state.js';
+import { dueFollowUp, markFired } from './event-followups.js';
+import { getCompanionConductor } from './orchestrator.js';
+import { resolveUserName } from './user-name.js';
+import { readRecentDialogueHearing } from './dialogue-percepts.js';
+import { resolveCurrentHomeInteractionPolicy, } from './home-interaction-policy.js';
+import { reserveDailyInteraction, } from './daily-interaction-budget.js';
+import { resolveHouseholdClock } from './household-time.js';
+// ── helpers ───────────────────────────────────────────────────────────
+/** Quiet/sleep window "START-END" (24h), default 22-8. Wraps midnight. */
+function isQuietHour(hour) {
+    const spec = process.env.CODEBUDDY_COMPANION_QUIET || '22-8';
+    const m = spec.match(/^(\d{1,2})-(\d{1,2})$/);
+    if (!m)
+        return false;
+    const start = Number(m[1]);
+    const end = Number(m[2]);
+    return start <= end ? hour >= start && hour < end : hour >= start || hour < end;
+}
+function pick(lines, now) {
+    // Deterministic-ish rotation (no Math.random for resumability friendliness).
+    return lines[Math.floor(now.getTime() / 60000) % lines.length];
+}
+const FRUSTRATION = /\b(j'?en peux plus|marre|galère|gal[èe]re|bloqu[ée]|coince|coincé|ça marche pas|ca marche pas|énerve|enerve|fatigu[ée]|épuis|sais plus)\b/i;
+// ── relationship-aware moments (shared history) ───────────────────────
+// Warm, sparse, non-gamified: a reunion after a real absence and a tenure milestone. Placed
+// FIRST so a genuine "welcome back" / "we've been together N days" wins over routine moments on
+// the tick it applies. Both fire at most once per occurrence (reunion: the sighting resets the
+// gap; milestone: `celebratedMilestones` records it).
+export const RELATIONSHIP_MOMENTS = [
+    {
+        id: 'reunion',
+        cooldownMs: 6 * 3600_000,
+        engage: true,
+        generate: (ctx) => ctx.daysSinceLastSeen >= REUNION_DAYS
+            ? pick([
+                `Te revoilà — ça faisait ${ctx.daysSinceLastSeen} jours. Content de te retrouver, tout va bien ?`,
+                `Ça faisait un moment, ${ctx.daysSinceLastSeen} jours sans te voir. Je suis contente que tu sois là.`,
+            ], ctx.now)
+            : null,
+    },
+    {
+        // "How did that go?" — an event Patrice mentioned earlier that has now passed. Placed high (a
+        // timely, personal follow-up), engages so he can answer back. Short cooldown so a due one
+        // surfaces on the next presence rather than waiting hours.
+        id: 'followup',
+        cooldownMs: 30 * 60_000,
+        engage: true,
+        generate: (ctx) => ctx.dueEventFollowUp?.followUp ?? null,
+    },
+    {
+        id: 'milestone',
+        cooldownMs: 20 * 3600_000,
+        generate: (ctx) => {
+            const m = pendingMilestone(ctx.daysTogether, ctx.celebratedMilestones);
+            return m == null
+                ? null
+                : pick([
+                    `Tu sais, ça fait ${m} jours qu'on se côtoie, toi et moi. J'aime bien notre bout de chemin.`,
+                    `${m} jours ensemble déjà. Merci d'être là, ${resolveUserName()}.`,
+                ], ctx.now);
+        },
+    },
+];
+// ── default moment library (priority order) ───────────────────────────
+export const DEFAULT_MOMENTS = [
+    ...RELATIONSHIP_MOMENTS,
+    {
+        id: 'encourage',
+        cooldownMs: 20 * 60_000,
+        generate: (ctx) => ctx.recentHearing.some((t) => FRUSTRATION.test(t))
+            ? pick([
+                'On garde simple. Le prochain petit pas utile, on le fait ensemble ?',
+                'Respire — on prend un truc à la fois. Par quoi on commence ?',
+                'Je suis là. On découpe : quel est le bout le plus petit qui avance ?',
+            ], ctx.now)
+            : null,
+    },
+    {
+        id: 'break',
+        cooldownMs: 45 * 60_000,
+        generate: (ctx) => ctx.drowsy ? 'Tu veux faire une petite pause ? Quelques minutes te feraient du bien.' : null,
+    },
+    {
+        id: 'project',
+        cooldownMs: 90 * 60_000,
+        engage: true,
+        generate: (ctx) => (ctx.projectThread ? `Au fait — ${ctx.projectThread}. Tu en es où ?` : null),
+    },
+    {
+        id: 'day-debrief',
+        cooldownMs: 12 * 3600_000,
+        engage: true,
+        generate: (ctx) => ctx.hour >= 19 && ctx.hour < 23
+            ? pick(['Alors, comment s’est passée ta journée ?', 'Raconte — ta journée, ça a donné quoi ?'], ctx.now)
+            : null,
+    },
+    {
+        id: 'time-of-day',
+        cooldownMs: 6 * 3600_000,
+        generate: (ctx) => {
+            if (ctx.hour >= 6 && ctx.hour < 11)
+                return pick([`Bonjour ${resolveUserName()}. Bien dormi ?`, 'Salut, belle journée qui commence.'], ctx.now);
+            if (ctx.hour >= 21 && ctx.hour < 24)
+                return pick([
+                    'Bonne soirée. Tu as bien avancé aujourd’hui.',
+                    'Doucement, la soirée — tu as bossé dur.',
+                ], ctx.now);
+            return null;
+        },
+    },
+];
+// ── the conductor ─────────────────────────────────────────────────────
+const lastFiredByMoment = new Map();
+let firedTimestamps = [];
+/** Test seam. */
+export function resetPresenceState() {
+    lastFiredByMoment.clear();
+    firedTimestamps = [];
+}
+function hourlyCap(deps) {
+    if (deps.hourlyCap !== undefined)
+        return deps.hourlyCap;
+    const n = Number(process.env.CODEBUDDY_COMPANION_PRESENCE_HOURLY_CAP);
+    return Number.isFinite(n) && n > 0 ? n : 4; // generous — he chose "vivant"
+}
+async function defaultSay(text) {
+    const [{ sayNow }, { speakCanonicalVoiceInitiative }] = await Promise.all([
+        import('../sensory/voice-loop.js'),
+        import('../conversation/voice-continuity.js'),
+    ]);
+    await speakCanonicalVoiceInitiative(text, (content) => sayNow(content, { phoneDelivery: 'never' }));
+}
+/**
+ * Presence files can be fresh while explicitly saying that nobody matched
+ * (`left`, `unknown`, or an empty camera frame). Only a confirmed match is a
+ * licence for an unsolicited spoken moment.
+ */
+export function hasConfirmedPresence(context) {
+    return context?.hasMatch === true;
+}
+async function defaultPersonPresent() {
+    try {
+        const { readPresenceContext } = await import('../memory/presence-injector.js');
+        const p = await readPresenceContext();
+        return hasConfirmedPresence(p);
+    }
+    catch {
+        return false;
+    }
+}
+async function defaultRecentHearing() {
+    return readRecentDialogueHearing(6);
+}
+/**
+ * One pass of the conductor. Exposed so tests drive it with a controlled clock + injected gates.
+ * Never-throws. Returns the spoken line (or null when it stayed silent) — for tests/logging.
+ */
+export async function runPresenceTick(deps = {}) {
+    try {
+        if (process.env.CODEBUDDY_COMPANION_PRESENCE !== 'true')
+            return null;
+        const now = (deps.now ?? (() => new Date()))();
+        const hour = resolveHouseholdClock(now).hour;
+        // — Rails (cheap-first) —
+        if (isQuietHour(hour))
+            return null; // never while you sleep
+        const present = await (deps.isPersonPresent ?? defaultPersonPresent)();
+        if (!present)
+            return null; // never to an empty room
+        const homeDecision = deps.homePolicy ? await deps.homePolicy(now) : null;
+        if (homeDecision && !homeDecision.allowed)
+            return null;
+        // — Shared-history bookkeeping — read the gap BEFORE recording this sighting, so the reunion
+        // moment (which can only fire on RETURN — the tick early-returns while absent) sees the real
+        // absence. Recorded even if we then bail on conversation/cap: a confirmed presence IS a sighting.
+        const nowMs = now.getTime();
+        const relState = loadRelationshipState(deps.relationshipStatePath);
+        if (relState.firstSeenAt == null)
+            relState.firstSeenAt = nowMs;
+        const daysTogether = daysBetween(relState.firstSeenAt, nowMs);
+        const daysSinceLastSeen = relState.lastPresentAt != null ? daysBetween(relState.lastPresentAt, nowMs) : 0;
+        relState.lastPresentAt = nowMs;
+        saveRelationshipState(relState, deps.relationshipStatePath);
+        if (await (deps.inConversation ?? (() => false))())
+            return null; // never over a live exchange
+        firedTimestamps = firedTimestamps.filter((t) => nowMs - t < 3600_000);
+        if (firedTimestamps.length >= hourlyCap(deps))
+            return null; // hourly cap
+        // A due event follow-up ("how did that deploy go?") — only read the store when the feature is
+        // enabled (env or an injected path), so we never touch the real home dir in default/tests.
+        const efEnabled = process.env.CODEBUDDY_COMPANION_EVENT_FOLLOWUPS === 'true' || deps.eventFollowUpsPath != null;
+        const due = efEnabled ? dueFollowUp(nowMs, deps.eventFollowUpsPath) : null;
+        // — Build context once —
+        const ctx = {
+            now,
+            hour,
+            personPresent: present,
+            recentHearing: await (deps.recentHearing ?? defaultRecentHearing)(),
+            drowsy: await (deps.drowsy ?? (() => false))(),
+            projectThread: await (deps.projectThread ?? (async () => null))(),
+            daysTogether,
+            daysSinceLastSeen,
+            celebratedMilestones: relState.celebratedMilestones,
+            dueEventFollowUp: due ? { id: due.id, followUp: due.followUp } : null,
+        };
+        // — Pick the first warranted moment that's off cooldown —
+        for (const moment of deps.moments ?? DEFAULT_MOMENTS) {
+            const last = lastFiredByMoment.get(moment.id) ?? Number.NEGATIVE_INFINITY;
+            if (nowMs - last < moment.cooldownMs)
+                continue;
+            const line = moment.generate(ctx);
+            if (!line)
+                continue;
+            let reservation = null;
+            if (homeDecision && deps.claimDailyBudget) {
+                reservation = await deps.claimDailyBudget(homeDecision.spontaneousDailyLimit, now);
+                if (!reservation.granted) {
+                    logger.info('[presence] shared household invitation budget exhausted');
+                    return null;
+                }
+            }
+            // Yield to the conductor only after a budget slot is reserved. A denied
+            // floor releases that slot, so neither shared guard is consumed falsely.
+            const conductor = deps.conductor ?? getCompanionConductor();
+            if (!conductor.claim('presence')) {
+                await reservation?.release();
+                logger.info('[presence] yielded to the conductor (another voice has the floor)');
+                return null;
+            }
+            try {
+                await (deps.say ?? defaultSay)(line);
+            }
+            catch (error) {
+                await reservation?.release();
+                throw error;
+            }
+            lastFiredByMoment.set(moment.id, nowMs);
+            firedTimestamps.push(nowMs);
+            if (moment.engage)
+                deps.onEngage?.();
+            // Record a celebrated tenure milestone (all marks up to today) so it never repeats.
+            if (moment.id === 'milestone') {
+                relState.celebratedMilestones = markMilestonesUpTo(relState.celebratedMilestones, daysTogether);
+                saveRelationshipState(relState, deps.relationshipStatePath);
+            }
+            // Mark a fired follow-up done so it's asked exactly once.
+            if (moment.id === 'followup' && due) {
+                markFired(due.id, nowMs, deps.eventFollowUpsPath);
+            }
+            logger.info(`[presence] ${moment.id} → ${line}`);
+            return line;
+        }
+        return null; // nothing fit → silent present
+    }
+    catch (err) {
+        logger.warn(`[presence] tick failed → silent: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/** Start the presence loop on its own interval (works without the sensory daemon). Returns teardown. */
+export function wirePresenceLoop(deps = {}) {
+    const tickMs = deps.tickMs ?? (Number(process.env.CODEBUDDY_COMPANION_PRESENCE_TICK_MS) || 300_000); // 5 min
+    const householdAwareDeps = {
+        ...deps,
+        homePolicy: deps.homePolicy ?? ((now) => resolveCurrentHomeInteractionPolicy('presence', { now })),
+        claimDailyBudget: deps.claimDailyBudget ?? ((limit, now) => reserveDailyInteraction({ limit, now, surface: 'presence' })),
+    };
+    const timer = setInterval(() => {
+        void runPresenceTick(householdAwareDeps);
+    }, tickMs);
+    if (typeof timer.unref === 'function')
+        timer.unref();
+    logger.info(`Companion presence: Enabled (tick ${Math.round(tickMs / 1000)}s, cap ${hourlyCap(deps)}/h)`);
+    return () => clearInterval(timer);
+}
+//# sourceMappingURL=presence-loop.js.map

package/dist/companion/privacy.js

@@ -1,10 +1,11 @@
-import { copyFile, mkdir, readdir, rm, stat, writeFile } from 'fs/promises';
+import { copyFile, mkdir, readdir, rm, stat } from 'fs/promises';
 import * as path from 'path';
 import { getCompanionCardsPath, readCompanionCards } from './cards.js';
 import { getCompanionGatewayProfilePath, readCompanionGatewayProfile } from './gateway.js';
 import { getCompanionPerceptsPath, getCompanionPerceptStats } from './percepts.js';
 import { getCompanionSafetyLedgerPath, getCompanionSafetyLedgerStats } from './safety-ledger.js';
 import { getCompanionSkillCandidatePath, readCompanionSkillCandidates } from './skill-curator.js';
+import { writeJsonAtomic } from '../utils/atomic-write.js';
 const ALL_KINDS = ['percepts', 'safety', 'cards', 'gateway', 'skills', 'camera'];
 function resolveCwd(cwd) {
     return cwd || process.cwd();
@@ -134,7 +135,7 @@ export async function exportCompanionPrivacyBundle(options = {}) {
     const report = await buildCompanionPrivacyReport({ cwd, now });
     const copied = (await Promise.all(uniqueKinds(options.kinds).map(kind => copyKind(cwd, exportDir, kind)))).flat();
     const manifestPath = path.join(exportDir, 'manifest.json');
-    await writeFile(manifestPath, `${JSON.stringify({ ...report, copied }, null, 2)}\n`, 'utf8');
+    await writeJsonAtomic(manifestPath, { ...report, copied }, { mode: 0o600 });
     return { exportDir, manifestPath, report, copied };
 }
 export async function purgeCompanionPrivacyData(options = {}) {

package/dist/companion/proactive-engine.d.ts

@@ -0,0 +1,97 @@
+import { type HomeInteractionDecision } from './home-interaction-policy.js';
+import { type DailyInteractionReservation } from './daily-interaction-budget.js';
+/** The closed set of reasons Lisa might reach out. */
+export type ProactiveTrigger = 'milestone' | 'inactivity' | 'followUp' | 'encouragement' | 'morning' | 'evening';
+export interface ProactiveContext {
+    now: number;
+    /** Local hour 0-23. */
+    hour: number;
+    /** Whole days since the companion first saw Patrice (0 if never). */
+    daysTogether: number;
+    /** Whole days since the last confirmed sighting (0 if never / present). */
+    daysSinceLastSeen: number;
+    /** Tenure milestones already celebrated — so a milestone fires exactly once. */
+    celebratedMilestones: number[];
+    /** An event he mentioned that is now due for a "how did it go?" — the followUp source. */
+    dueEventFollowUp?: {
+        id: string;
+        followUp: string;
+    } | null;
+    /** Recent frustration heard → an encouragement opening. */
+    recentFrustration?: boolean;
+}
+export interface ProactiveCandidate {
+    trigger: ProactiveTrigger;
+    /** Higher wins (MySoulmate's priorities). */
+    priority: number;
+    /** Interpolation data for the template ({{days}} / {{event}}). */
+    data: Record<string, string | number>;
+}
+/** A return after this many days without a sighting warrants a check-in. */
+export declare const INACTIVITY_DAYS: number;
+/**
+ * Score the applicable triggers for a context, highest priority first (mirrors MySoulmate's
+ * `evaluateTriggers`/`localEvaluate`). Pure. The caller takes the single top candidate.
+ */
+export declare function evaluateTriggers(ctx: ProactiveContext): ProactiveCandidate[];
+/** The single winning trigger, or null when nothing applies. */
+export declare function pickTrigger(ctx: ProactiveContext): ProactiveCandidate | null;
+/**
+ * Template pools (French, ≤2 sentences, warm, non-intrusive). `followUp` is just `{{event}}` because
+ * the event-followup text is already a complete "how did it go?" question.
+ */
+export declare const PROACTIVE_TEMPLATES: Record<ProactiveTrigger, string[]>;
+/** Pick a line for a candidate, avoiding the same template twice in a row (per trigger). */
+export declare function pickProactiveLine(candidate: ProactiveCandidate, rng?: () => number): string;
+export interface ProactiveState {
+    /** Epoch ms of the last proactive message sent (any trigger) — the cooldown anchor. */
+    lastSentAt?: number;
+    /** Recently sent lines (anti-repetition / LLM avoid-list). */
+    recentLines: string[];
+}
+export declare function loadProactiveState(statePath?: string): ProactiveState;
+export declare function saveProactiveState(state: ProactiveState, statePath?: string): boolean;
+/** True when at least `cooldownMs` has passed since the last proactive message. */
+export declare function canSend(state: ProactiveState, now: number, cooldownMs: number): boolean;
+export interface ProactiveDeps {
+    now?: () => number;
+    /** Someone is in front of the camera right now (→ speak vs Telegram). */
+    present?: () => boolean | Promise<boolean>;
+    /** True while the mouth (or its echo tail) is already taken — do not talk over it. */
+    speaking?: (now: number) => boolean | Promise<boolean>;
+    /** Deliver aloud (present). Default: sayNow (Piper). True only when speech actually played. */
+    say?: (text: string) => Promise<boolean>;
+    /** Deliver to the phone (absent). Default: sendTelegramVoice (falls back to text). */
+    telegramVoice?: (text: string) => Promise<boolean>;
+    /** Text Telegram for travel-mode initiatives. Default: sendTelegramAlert. */
+    telegramAlert?: (text: string) => Promise<boolean>;
+    /** Persisted away-mode cadence (angles / pause). */
+    awayStatePath?: string;
+    /** Append an already-delivered remote initiative without echoing it. */
+    recordRemote?: (text: string) => Promise<void>;
+    /** Recent transcripts (for the encouragement trigger). */
+    recentHearing?: () => Promise<string[]>;
+    /** Optional LLM freshening of the chosen line → returns null to keep the template. */
+    refine?: (trigger: ProactiveTrigger, base: string, avoid: string[]) => Promise<string | null>;
+    cooldownMs?: number;
+    rng?: () => number;
+    statePath?: string;
+    relationshipStatePath?: string;
+    /** Enables the due-follow-up read (env or an injected path), mirroring the presence loop. */
+    eventFollowUpsPath?: string;
+    /** The shared conductor (arbitrates who speaks). Default: the singleton. Injectable for tests. */
+    conductor?: {
+        claim: (surface: 'proactive') => boolean;
+    };
+    /** Household posture/calendar gate. Wired by `wireProactiveLoop`; injectable for tests. */
+    homePolicy?: (surface: 'proactive-local' | 'proactive-remote', now: Date) => Promise<HomeInteractionDecision>;
+    /** Shared cross-surface daily invitation budget. Wired by `wireProactiveLoop`. */
+    claimDailyBudget?: (limit: number, now: Date) => Promise<DailyInteractionReservation>;
+}
+/**
+ * One pass of the proactive engine. Returns the line sent (or null if it stayed silent). Never
+ * throws. Exposed so tests drive it with a controlled clock + injected delivery/present seams.
+ */
+export declare function runProactiveTick(deps?: ProactiveDeps): Promise<string | null>;
+/** Start the proactive loop on its own interval (works without the camera). Returns teardown. */
+export declare function wireProactiveLoop(deps?: ProactiveDeps): () => void;