@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/security/write-policy.js

@@ -9,9 +9,31 @@
  * The singleton is injectable for tests via WritePolicy.setInstance().
  */
 import { logger } from '../utils/logger.js';
+import { toLegacyName } from '../tools/registry/tool-aliases.js';
+import { RunStore } from '../observability/run-store.js';
 // ──────────────────────────────────────────────────────────────────
 // Tool names that trigger write-policy gating
 // ──────────────────────────────────────────────────────────────────
+/** Detect shell commands that write the workspace instead of using apply_patch. */
+export function isShellWriteCommand(command) {
+    const c = command.trim();
+    if (!c)
+        return false;
+    if (/(?:^|\s)(?:tee|install|cp|mv|rm|touch|mkdir|dd|truncate)\b/.test(c))
+        return true;
+    if (/(?:^|&&|\|\||;)\s*(?:cat|printf|echo)\b[\s\S]*[>\u003e]/.test(c))
+        return true;
+    if (/[>\u003e]{1,2}\s*\/|[>\u003e]{1,2}\s*\S/.test(c) && !/\b2>\s*\/dev\/null\b/.test(c.split('>')[0] ?? '')) {
+        if (/(?:^|\s)(?:grep|rg|find|ls|head|tail|wc|git|npm|node|python)\b/.test(c) && !/[>\u003e]/.test(c)) {
+            return false;
+        }
+        if (/[>\u003e]/.test(c) && !/2>\s*\/dev\/null/.test(c))
+            return true;
+    }
+    if (/<<['"]?\w+/.test(c))
+        return true;
+    return false;
+}
 export const WRITE_TOOL_NAMES = new Set([
     'str_replace_editor',
     'create_file',
@@ -19,6 +41,8 @@ export const WRITE_TOOL_NAMES = new Set([
     'apply_patch',
     'edit_file', // Morph Fast Apply
     'write_file',
+    'extension_forge',
+    'meeting_notes', // ToolHandler gates this only when output_prefix is present.
 ]);
 // ──────────────────────────────────────────────────────────────────
 // WritePolicy
@@ -70,6 +94,7 @@ export class WritePolicy {
             case 'confirm': {
                 // In confirm mode, direct writes are allowed but we log the decision
                 const result = { allowed: true, requiresPatch: false };
+                this.recordDecision(_runId, operation, result);
                 this.notifyListeners(operation, result);
                 return result;
             }
@@ -94,7 +119,27 @@ export class WritePolicy {
      * Returns true if the tool name is subject to write-policy gating.
      */
     isWriteTool(toolName) {
-        return WRITE_TOOL_NAMES.has(toolName);
+        return WRITE_TOOL_NAMES.has(toLegacyName(toolName));
+    }
+    /**
+     * Strict mode also blocks bash/shell redirects so agents cannot bypass
+     * apply_patch with `echo x > file`.
+     */
+    async gateShell(command) {
+        if (this.mode !== 'strict') {
+            return { allowed: true, requiresPatch: false };
+        }
+        if (!isShellWriteCommand(command)) {
+            return { allowed: true, requiresPatch: false };
+        }
+        const result = {
+            allowed: false,
+            requiresPatch: true,
+            reason: 'WritePolicy (strict): shell write blocked. Use apply_patch with a unified diff instead.',
+        };
+        this.notifyListeners({ toolName: 'bash', paths: [], description: command }, result);
+        logger.info('WritePolicy blocked: bash shell write');
+        return result;
     }
     // ── Observability ─────────────────────────────────────────────
     /**
@@ -113,5 +158,22 @@ export class WritePolicy {
             }
         }
     }
+    recordDecision(runId, operation, result) {
+        if (!runId)
+            return;
+        RunStore.getInstance().emit(runId, {
+            type: 'decision',
+            data: {
+                kind: 'write_policy',
+                mode: this.mode,
+                allowed: result.allowed,
+                requiresPatch: result.requiresPatch,
+                toolName: operation.toolName,
+                paths: [...operation.paths],
+                ...(operation.description ? { description: operation.description } : {}),
+                ...(result.reason ? { reason: result.reason } : {}),
+            },
+        });
+    }
 }
 //# sourceMappingURL=write-policy.js.map

package/dist/self-model/evolution-notes.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Structured, local notes about Code Buddy's own released changes.
+ *
+ * Parsing is deliberately pure. The asynchronous loader only reads the
+ * project's CHANGELOG.md and maintains a cache below `.codebuddy/`, never in
+ * the user's home directory. This makes the self-model useful to the CLI,
+ * Lisa, and the self-improvement loop without making any provider request.
+ *
+ * @module self-model/evolution-notes
+ */
+export type EvolutionActivation = 'opt-in' | 'default' | 'mixed' | 'unspecified';
+export interface EvolutionNote {
+    /** Stable local identifier used by the cache and the evolutionary archive. */
+    id: string;
+    /** ISO calendar date, or null for an undated Unreleased section. */
+    date: string | null;
+    title: string;
+    /** One concise sentence per fact. */
+    facts: string[];
+    /** Newly mentioned environment variables. */
+    variables: string[];
+    /** Newly mentioned CLI or slash commands. */
+    commands: string[];
+    activation: EvolutionActivation;
+}
+export interface EvolutionNotesQuery {
+    since?: string;
+    subject?: string;
+    limit?: number;
+}
+export interface ReadEvolutionNotesOptions {
+    workDir?: string;
+    changelogPath?: string;
+    cachePath?: string;
+    /** Tests and embedders may provide a project-local reader/writer. */
+    readFile?: (filePath: string) => Promise<string>;
+    writeFile?: (filePath: string, content: string) => Promise<void>;
+    mkdir?: (directory: string) => Promise<void>;
+}
+/** Parse a CHANGELOG fixture without reading or writing anything. */
+export declare function parseEvolutionNotes(markdown: string): EvolutionNote[];
+/** Filter and sort notes for a question such as "since 2026-09-01" or "voice". */
+export declare function queryEvolutionNotes(notes: readonly EvolutionNote[], options?: EvolutionNotesQuery): EvolutionNote[];
+/** At most three first-person, non-repository lines for Lisa's relational prompt. */
+export declare function formatEvolutionNotesForCompanion(notes: readonly EvolutionNote[]): string;
+/** Compact plain text for a voice answer; it is intentionally not Markdown. */
+export declare function formatEvolutionNotesForVoice(notes: readonly EvolutionNote[]): string;
+/** Condensed structured output for the `self_evolution` tool. */
+export declare function formatEvolutionNotesSummary(notes: readonly EvolutionNote[]): string;
+/** Read, cache, and return the project's structured evolution notes. */
+export declare function readEvolutionNotes(options?: ReadEvolutionNotesOptions): Promise<EvolutionNote[]>;

package/dist/self-model/evolution-notes.js

@@ -0,0 +1,324 @@
+/**
+ * Structured, local notes about Code Buddy's own released changes.
+ *
+ * Parsing is deliberately pure. The asynchronous loader only reads the
+ * project's CHANGELOG.md and maintains a cache below `.codebuddy/`, never in
+ * the user's home directory. This makes the self-model useful to the CLI,
+ * Lisa, and the self-improvement loop without making any provider request.
+ *
+ * @module self-model/evolution-notes
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { readTextAtomic, writeFileAtomic } from '../utils/atomic-write.js';
+const MONTHS = {
+    janvier: '01',
+    january: '01',
+    février: '02',
+    fevrier: '02',
+    february: '02',
+    mars: '03',
+    march: '03',
+    avril: '04',
+    april: '04',
+    mai: '05',
+    may: '05',
+    juin: '06',
+    june: '06',
+    juillet: '07',
+    july: '07',
+    août: '08',
+    aout: '08',
+    august: '08',
+    septembre: '09',
+    september: '09',
+    octobre: '10',
+    october: '10',
+    novembre: '11',
+    november: '11',
+    décembre: '12',
+    decembre: '12',
+    december: '12',
+};
+function normalizeText(value) {
+    return value
+        .replace(/\r/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function privacySafe(value) {
+    return value
+        .replace(/\bpatrice\b/gi, 'la personne utilisatrice')
+        .replace(/\/home\/[^\s`),]+/g, 'un chemin local')
+        .replace(/\b[0-9a-f]{12,}\b/gi, 'une révision');
+}
+function markdownSafe(value) {
+    return privacySafe(value
+        .replace(/!?(\[([^\]]+)\])\([^)]*\)/g, '$2')
+        .replace(/\*\*|__|~~/g, '')
+        .replace(/<[^>]+>/g, ''));
+}
+function sentence(value) {
+    const cleaned = normalizeText(markdownSafe(value)).replace(/^[-*+]\s+/, '');
+    if (!cleaned)
+        return '';
+    const firstSentence = cleaned.match(/^.*?(?:[.!?…](?=\s|$)|$)/)?.[0]?.trim() ?? cleaned;
+    const bounded = firstSentence.length > 420 ? `${firstSentence.slice(0, 417).trimEnd()}…` : firstSentence;
+    return /[.!?…]$/.test(bounded) ? bounded : `${bounded}.`;
+}
+function slug(value) {
+    const normalized = value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    return normalized.slice(0, 80) || 'note';
+}
+function extractDate(value) {
+    const iso = value.match(/\b(20\d{2})-(\d{2})-(\d{2})\b/);
+    if (iso)
+        return `${iso[1]}-${iso[2]}-${iso[3]}`;
+    const named = value.toLowerCase().match(/\b(?:du\s+)?(\d{1,2})(?:\s+au\s+(\d{1,2}))?\s+([a-zàâçéèêëîïôûùüÿ]+)\s+(20\d{2})\b/);
+    if (!named)
+        return null;
+    const month = MONTHS[named[3]];
+    const day = named[2] ?? named[1];
+    return month && day ? `${named[4]}-${month}-${day.padStart(2, '0')}` : null;
+}
+function stripDateSuffix(title) {
+    return title
+        .replace(/\s+[—–-]\s+(?:nuit du|du\s+\d|\d{1,2}\s+[a-zàâçéèêëîïôûùüÿ]+\s+20\d{2}).*$/i, '')
+        .trim();
+}
+function extractFacts(body) {
+    const lines = body.replace(/\r/g, '').split('\n');
+    const facts = [];
+    let current = '';
+    let sawBullet = false;
+    const flush = () => {
+        const value = sentence(current);
+        if (value)
+            facts.push(value);
+        current = '';
+    };
+    for (const line of lines) {
+        if (/^\s*(?:[-*+]|\d+[.)])\s+/.test(line)) {
+            sawBullet = true;
+            flush();
+            current = line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, '');
+            continue;
+        }
+        if (!line.trim()) {
+            if (!sawBullet)
+                flush();
+            continue;
+        }
+        if (/^#{1,6}\s+/.test(line))
+            continue;
+        current = current ? `${current} ${line.trim()}` : line.trim();
+    }
+    flush();
+    return [...new Set(facts)].slice(0, 12);
+}
+function codeSpans(value) {
+    return [...value.matchAll(/`([^`]+)`/g)].map((match) => match[1].trim()).filter(Boolean);
+}
+function extractVariables(body) {
+    const values = new Set();
+    const candidates = [body, ...codeSpans(body)];
+    for (const candidate of candidates) {
+        for (const match of candidate.matchAll(/\b[A-Z][A-Z0-9_]*_[A-Z0-9_]+\b/g))
+            values.add(match[0]);
+    }
+    return [...values].slice(0, 30);
+}
+function extractCommands(body) {
+    const values = new Set();
+    for (const candidate of codeSpans(body)) {
+        if (/^(?:buddy\b|\/[-a-z])/i.test(candidate))
+            values.add(normalizeText(candidate));
+    }
+    return [...values].slice(0, 30);
+}
+function activationFor(value) {
+    const text = value.toLowerCase();
+    const optIn = /opt[- ]?in|opt[- ]?out|default off|par défaut[^.\n]*(?:off|désactiv|desactiv)|without (?:their|the) env|sans (?:leur|la) variable|=true pour l?['’]?opt/i.test(text);
+    const defaultOn = /enabled by default|activé par défaut|active par défaut|default(?:s)? to on|par défaut[^.\n]*(?:actif|activé|on)/i.test(text);
+    if (optIn && defaultOn)
+        return 'mixed';
+    if (optIn)
+        return 'opt-in';
+    if (defaultOn)
+        return 'default';
+    return 'unspecified';
+}
+function sectionNotes(markdown) {
+    const lines = markdown.replace(/\r/g, '').split('\n');
+    const sections = [];
+    let releaseDate = null;
+    let current = null;
+    const flush = () => {
+        if (!current)
+            return;
+        sections.push({ title: current.title, date: current.date ?? releaseDate, body: current.lines.join('\n') });
+        current = null;
+    };
+    for (const line of lines) {
+        const heading = line.match(/^(#{2,3})\s+(.+?)\s*$/);
+        const headingLevel = heading?.[1];
+        const headingTitle = heading?.[2];
+        if (headingLevel?.length === 2 && headingTitle) {
+            flush();
+            releaseDate = extractDate(headingTitle);
+            continue;
+        }
+        if (headingLevel?.length === 3 && headingTitle) {
+            flush();
+            current = { title: stripDateSuffix(markdownSafe(headingTitle)), date: extractDate(headingTitle), lines: [] };
+            continue;
+        }
+        if (current)
+            current.lines.push(line);
+    }
+    flush();
+    return sections;
+}
+/** Parse a CHANGELOG fixture without reading or writing anything. */
+export function parseEvolutionNotes(markdown) {
+    const seen = new Map();
+    return sectionNotes(markdown).map((section) => {
+        const facts = extractFacts(section.body);
+        const variables = extractVariables(section.body);
+        const commands = extractCommands(section.body);
+        const baseId = `${section.date ?? 'unreleased'}:${slug(section.title)}`;
+        const occurrence = seen.get(baseId) ?? 0;
+        seen.set(baseId, occurrence + 1);
+        return {
+            id: occurrence === 0 ? baseId : `${baseId}:${occurrence + 1}`,
+            date: section.date,
+            title: section.title,
+            facts,
+            variables,
+            commands,
+            activation: activationFor(`${section.title}\n${section.body}`),
+        };
+    });
+}
+function dateValue(value) {
+    return value ? Date.parse(`${value}T00:00:00.000Z`) : Number.NEGATIVE_INFINITY;
+}
+function normalizedSubject(value) {
+    return value
+        .toLowerCase()
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim();
+}
+/** Filter and sort notes for a question such as "since 2026-09-01" or "voice". */
+export function queryEvolutionNotes(notes, options = {}) {
+    const since = options.since ? dateValue(options.since) : Number.NEGATIVE_INFINITY;
+    const subject = options.subject ? normalizedSubject(options.subject) : '';
+    const terms = subject.split(' ').filter((term) => term.length >= 2);
+    const limit = Math.max(1, Math.min(50, options.limit ?? 5));
+    return [...notes]
+        .filter((note) => dateValue(note.date) >= since)
+        .filter((note) => {
+        if (terms.length === 0)
+            return true;
+        const haystack = normalizedSubject([
+            note.title,
+            ...note.facts,
+            ...note.variables,
+            ...note.commands,
+        ].join(' '));
+        return terms.some((term) => haystack.includes(term));
+    })
+        .sort((left, right) => dateValue(right.date) - dateValue(left.date))
+        .slice(0, limit);
+}
+function friendlyCompanionLine(note) {
+    const text = normalizedSubject(`${note.title} ${note.facts[0] ?? ''}`);
+    if (/(robot|voix|entend|echo|ecoute|parole|audio)/.test(text)) {
+        return 'J’ai récemment appris à mieux distinguer ta voix de la mienne.';
+    }
+    if (/(fiabil|execution|verif|succes|test)/.test(text)) {
+        return 'J’ai récemment appris à mieux vérifier ce que j’annonce avant de le dire.';
+    }
+    if (/(memoire|contexte|conversation|compagnon|relation)/.test(text)) {
+        return 'J’ai récemment appris à mieux garder le fil de nos échanges.';
+    }
+    return `J’ai récemment appris quelque chose de nouveau sur ma façon de répondre : ${note.title.toLowerCase()}.`;
+}
+/** At most three first-person, non-repository lines for Lisa's relational prompt. */
+export function formatEvolutionNotesForCompanion(notes) {
+    return notes
+        .slice(0, 3)
+        .map(friendlyCompanionLine)
+        .join('\n');
+}
+/** Compact plain text for a voice answer; it is intentionally not Markdown. */
+export function formatEvolutionNotesForVoice(notes) {
+    if (notes.length === 0)
+        return 'Je n’ai pas encore de note de version récente à consulter.';
+    return formatEvolutionNotesForCompanion(notes);
+}
+/** Condensed structured output for the `self_evolution` tool. */
+export function formatEvolutionNotesSummary(notes) {
+    if (notes.length === 0)
+        return 'Aucune note d’évolution récente trouvée.';
+    return notes.map((note) => {
+        const date = note.date ?? 'date inconnue';
+        const fact = note.facts[0] ?? 'Aucun fait détaillé dans la section.';
+        const activation = note.activation === 'unspecified' ? '' : ` Activation : ${note.activation}.`;
+        return `- ${date} — ${note.title} : ${fact}${activation}`;
+    }).join('\n');
+}
+function cacheIsValid(value, source) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const cache = value;
+    return (cache.schemaVersion === 1 &&
+        cache.source?.mtimeMs === source.mtimeMs &&
+        cache.source?.size === source.size &&
+        Array.isArray(cache.notes));
+}
+/** Read, cache, and return the project's structured evolution notes. */
+export async function readEvolutionNotes(options = {}) {
+    const workDir = path.resolve(options.workDir ?? process.cwd());
+    const changelogPath = path.resolve(options.changelogPath ?? path.join(workDir, 'CHANGELOG.md'));
+    const cachePath = path.resolve(options.cachePath ?? path.join(workDir, '.codebuddy', 'self-model', 'evolution.json'));
+    const readFile = options.readFile ?? ((filePath) => fs.readFile(filePath, 'utf8'));
+    const readCacheFile = options.readFile ?? ((filePath) => readTextAtomic(filePath, ''));
+    const writeFile = options.writeFile ?? ((filePath, content) => writeFileAtomic(filePath, content, { mode: 0o600 }));
+    const mkdir = options.mkdir ?? ((directory) => fs.mkdir(directory, { recursive: true }));
+    let source;
+    let markdown;
+    try {
+        const stat = await fs.stat(changelogPath);
+        source = { mtimeMs: stat.mtimeMs, size: stat.size };
+        markdown = await readFile(changelogPath);
+    }
+    catch {
+        return [];
+    }
+    try {
+        const cached = JSON.parse(await readCacheFile(cachePath));
+        if (cacheIsValid(cached, source))
+            return cached.notes;
+    }
+    catch {
+        // A missing or corrupt cache is rebuilt from the source below.
+    }
+    const notes = parseEvolutionNotes(markdown);
+    try {
+        await mkdir(path.dirname(cachePath));
+        await writeFile(cachePath, JSON.stringify({ schemaVersion: 1, source, notes }, null, 2));
+    }
+    catch {
+        // Read-only installs still get the parsed model; caching is best-effort.
+    }
+    return notes;
+}
+//# sourceMappingURL=evolution-notes.js.map

package/dist/sensory/agent-reply.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Agent reply — the "voice COMMAND" brain. Turns a spoken instruction into a REAL
+ * agent turn that can investigate AND act (edit files, run commands), then returns
+ * the result as 1-2 spoken French sentences. The agent is asked to produce that compact
+ * result directly; a second summarizing LLM pass remains only as a compatibility fallback.
+ * This is the `replyFn` that upgrades the
+ * sensory voice loop from a chatty companion into something you can *tell what to do*:
+ *
+ *   makeVoiceReply({ replyFn: makeAgentReply({ permissionMode }) })
+ *
+ * Safety is the crux (a misheard transcript could try to run a command), so every agent
+ * turn runs under an EXPLICIT, async-scoped permission posture via the SAME
+ * `PermissionModeManager` the `ConfirmationService` already consults — no parallel gate
+ * and no process-global mode leak into an interactive/Cowork session:
+ *
+ *   - 'default' (resident default): reads and policy-approved safe shell commands work;
+ *                         writes and risky actions keep their normal confirmation gates.
+ *   - 'plan'            : explicit read-only command session (for `buddy voice --mode plan`).
+ *   - 'dontAsk'/'bypass': edits + shell execute (still behind the static command
+ *                         validator + secret/deploy guard + kill switch). Opt-in, loud.
+ *
+ * Everything is INJECTABLE (agentRunner / summarize / ack) so it's deterministically
+ * testable with no model. NEVER-THROWS: a failure becomes a short spoken apology, not a
+ * crash. $0 when routed to a local model.
+ *
+ * @module sensory/agent-reply
+ */
+import type { ReplyFn, StreamReplyFn, VoiceStepOptions } from './voice-loop.js';
+import type { PermissionMode } from '../security/permission-modes.js';
+/** Run a full agent turn for the transcript, return the assistant's final text.
+ *  `opts.signal` (optional) lets a barge-in abort the turn's LLM calls. */
+export interface AgentRunner {
+    (transcript: string, opts?: VoiceStepOptions): Promise<string>;
+    /** Stream final-answer text deltas from the agent lane. */
+    stream?: StreamReplyFn;
+    /** Build or retarget a standby while the human is still speaking. */
+    prewarm?: (transcriptHint?: string) => Promise<void>;
+    /** Release an unused standby during server teardown. */
+    dispose?: () => void;
+}
+/** Condense a (possibly long, markdown) agent answer into 1-2 spoken FR sentences.
+ *  `opts.signal` (optional) lets a barge-in abort the summarizing LLM call. */
+export type SummarizeFn = (agentOutput: string, transcript: string, opts?: VoiceStepOptions) => Promise<string>;
+export interface AgentReplyOptions {
+    /** Voice ACT posture, scoped to each turn. Default 'default' (normal guarded permissions). */
+    permissionMode?: PermissionMode;
+    /** Working directory for the agent turn. Default process.cwd(). */
+    cwd?: string;
+    /** Injectable: run the full agent turn. Default builds a headless CodeBuddyAgent. */
+    agentRunner?: AgentRunner;
+    /** Injectable: condense the agent output for speech. A generative custom
+     *  summarizer must call `opts.onProviderResolved` so private review routing
+     *  can stay on its exact provider. Default: fast LLM + SPEAK prompt. */
+    summarize?: SummarizeFn;
+    /** Optional spoken acknowledgement played while the slow turn starts in parallel,
+     *  e.g. "d'accord, je regarde…". Default: none (the ReplyFn contract returns one string;
+     *  wire this where synth+play exist). */
+    ack?: (transcript: string, opts?: VoiceStepOptions) => Promise<void>;
+    /** Spoken when the turn fails (never-throws). Default: a short FR apology. */
+    apology?: string;
+}
+/** Reply function plus the predictive lifecycle used by the live VAD hook. */
+export interface AgentReplyHandler extends ReplyFn {
+    /** Token-delta path used by the sentence-level voice pipeline. */
+    stream: StreamReplyFn;
+    prewarm(transcriptHint?: string): Promise<void>;
+    dispose(): void;
+}
+/** Narrow seam around CodeBuddyAgent, exported so abort propagation is testable
+ * without constructing a real provider/MCP stack. */
+export interface InterruptibleVoiceAgent {
+    processUserMessageStream(message: string, options?: {
+        transientContext?: string;
+        relationshipSafety?: boolean;
+        surface?: string;
+        introspectionText?: string;
+    }): AsyncIterable<unknown>;
+    getChatHistory(): Array<{
+        type?: string;
+        content?: unknown;
+    }>;
+    abortCurrentOperation(): void;
+    suspendTranscriptSnapshots?(): void;
+}
+/**
+ * Appended to the grounded agent's SYSTEM prompt on every tool round. Keeping the
+ * instruction at system level (rather than concatenating it to the transcript) both
+ * preserves the user's exact request for the fallback summarizer and makes the final
+ * agent response directly usable by TTS in the normal case.
+ */
+export declare const GROUNDED_VOICE_SYSTEM_PROMPT_APPEND = "<voice_response_contract>\nCette interaction se d\u00E9roule \u00E0 voix haute. Utilise les outils n\u00E9cessaires, mais n'annonce pas ce que tu vas faire et ne raconte pas les appels d'outils avant ou pendant leur ex\u00E9cution.\nDans ta r\u00E9ponse finale uniquement, r\u00E9ponds en fran\u00E7ais avec des phrases compl\u00E8tes et un raisonnement coh\u00E9rent. Adapte la longueur \u00E0 la profondeur de la demande et suis le conversation_response_plan lorsqu'il est fourni.\nUne salutation reste br\u00E8ve. Une r\u00E9ponse factuelle expose le r\u00E9sultat, sa raison et sa source. Une discussion philosophique ou un d\u00E9saccord peut d\u00E9velopper une position, ses raisons, une objection honn\u00EAte, une concession et une synth\u00E8se.\nN'utilise ni Markdown, ni bloc de code, ni code en ligne, ni liste.\n</voice_response_contract>";
+export declare function spokenPrefixContinuationGuidance(spokenPrefix?: string): string;
+/**
+ * Token budget for the spoken summary.
+ *
+ * `CODEBUDDY_VOICE_MAX_TOKENS` is an OPERATOR decision about how long the robot
+ * should talk, so an explicit value is honoured as the ceiling. It used to be
+ * merely a lower input to `Math.max(96, …, conversationTokenBudget(…))`, which
+ * meant a deliberate 48 became at least 96 and, on a long exchange, up to 512.
+ * Measured on Patrice's robot on 2026-09-02: he had set 48 and heard a 656-character
+ * answer delivered as fourteen separate phrases.
+ *
+ * Unset, the automatic budget keeps its previous behaviour exactly.
+ */
+declare function summaryMaxTokens(transcript: string, env?: NodeJS.ProcessEnv): number;
+/** Exposed for tests: the budget rule is a user-visible contract. */
+export declare const __testSummaryMaxTokens: typeof summaryMaxTokens;
+/** Skip the second LLM call only when the grounded agent respected the voice contract. */
+export declare function isAlreadySpeakableAgentResult(output: string): boolean;
+/**
+ * Voice introspection must not pass through a second generative model: a
+ * summarizer can erase evidence status or manufacture a consciousness claim.
+ * Flatten the already-grounded answer deterministically and finish with the
+ * non-subjective boundary every time.
+ */
+export declare function prepareSelfInspectionVoiceReply(output: string, request?: string): string;
+/** Keep the self-evolution answer grounded and short on the spoken path. */
+export declare function prepareEvolutionVoiceReply(output: string): string;
+/** Consume the agent's streaming path even though voice only needs the final
+ * history entry. Unlike the sequential collector, this path owns an
+ * AbortController, so an explicit barge-in cancels provider I/O for real. */
+export declare function runInterruptibleVoiceAgentTurn(agent: InterruptibleVoiceAgent, transcript: string, opts?: VoiceStepOptions): Promise<string>;
+/**
+ * Yield the grounded agent's real text deltas as they arrive. The voice loop owns the
+ * sentence-level relationship guard and sanitizer, so this path asks the executor for raw
+ * display deltas instead of its whole-answer relationship buffer. Tool permission and command
+ * safety remain enforced by the normal agent turn. A thrown/empty stream is intentionally left
+ * observable to the caller, which can then use the blocking fallback.
+ */
+export declare function streamInterruptibleVoiceAgentTurn(agent: InterruptibleVoiceAgent, transcript: string, opts?: VoiceStepOptions): AsyncGenerator<string, void, unknown>;
+/**
+ * Build an `onHeard`-compatible `ReplyFn` that drives a full agent turn and returns a
+ * spoken-length summary. Applies scoped permission/workspace context per turn. Never-throws.
+ */
+export declare function makeAgentReply(options?: AgentReplyOptions): AgentReplyHandler;
+export {};