@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/companion/companion-toolset.js

@@ -0,0 +1,368 @@
+/**
+ * Companion Toolset definition, authorization and execution gates.
+ *
+ * Defines which tools Lisa can use based on the interlocutor's identity tier:
+ * - 'owner': image_generate, image_edit, remind, web_search, weather, stock_quote,
+ *            understand_video, camera_analyze, recall.
+ * - 'present': same tools WITHOUT remind and WITHOUT camera (camera_analyze).
+ * - 'guest': NO tools (fail-closed, byte-identical to historical turn).
+ *
+ * Hard security invariants:
+ * - NEVER bash, shell_exec, file writing (create_file, edit, patch), MCP, fleet tools.
+ * - Circuit-breaker: CODEBUDDY_COMPANION_TOOLS_ENABLED (default: false -> 0 tools).
+ * - Surcharge: CODEBUDDY_COMPANION_TOOLS (csv list, filtered against hard constraints).
+ *
+ * @module companion/companion-toolset
+ */
+import path from 'path';
+import { logger } from '../utils/logger.js';
+import { FormalToolRegistry } from '../tools/registry/tool-registry.js';
+export const OWNER_COMPANION_TOOLS = Object.freeze([
+    'image_generate',
+    'image_edit',
+    'remind',
+    'web_search',
+    'weather',
+    'stock_quote',
+    'understand_video',
+    'camera_analyze',
+    'recall',
+]);
+export const PRESENT_COMPANION_TOOLS = Object.freeze([
+    'image_generate',
+    'image_edit',
+    'web_search',
+    'weather',
+    'stock_quote',
+    'understand_video',
+    'recall',
+]);
+export const GUEST_COMPANION_TOOLS = Object.freeze([]);
+/** Strictly forbidden tool patterns that can NEVER be exposed to companion */
+export const COMPANION_FORBIDDEN_PATTERNS = Object.freeze([
+    // bash* family (bash, bash_exec, etc.)
+    /^bash/i,
+    'terminal',
+    'interactive_shell',
+    // shell* family (shell_exec, shell_git, shell_process, shell_docker, shell_k8s, etc.)
+    /^shell/i,
+    // *_exec family and code execution (code_exec, shell_exec, execute_code, etc.)
+    /(?:^|_)exec(?:$|_)/i,
+    /^execute_/i,
+    'js_repl',
+    // write_* family & file writing
+    /^write_/i,
+    /^file_write/i,
+    'create_file',
+    // patch family
+    'patch',
+    /^apply_patch/i,
+    // str_replace* family (str_replace, str_replace_editor, etc.)
+    /^str_replace/i,
+    // multi_edit and edit_* family (file editing; does NOT match image_edit)
+    'multi_edit',
+    /^multi_edit/i,
+    /^edit_/i,
+    /^file_edit/i,
+    // delete_* family
+    /^delete_/i,
+    // system / infra / process / code execution / app server
+    'docker',
+    'kubernetes',
+    'process',
+    /^process/i,
+    'git',
+    /^git_/i,
+    'resolve_conflicts',
+    'app_server',
+    'computer_control',
+    'office_macro_execute',
+    'codebase_replace',
+    'scaffold_app',
+    'tool_search',
+    'extension_forge',
+    'scan_vulnerabilities',
+    'env_doctor',
+    'resource_catalog',
+    'port_check',
+    'lint_project',
+    'test_runner',
+    'format_project',
+    'build_project',
+    // A2A / MCP / orchestration / registration
+    /^a2a_/i,
+    /^mcp_/i,
+    /^fleet_/i,
+    /^peer_/i,
+    /^delegate_/i,
+    /^register_tool/i,
+    'register_tool',
+]);
+/**
+ * Check if a tool is strictly forbidden for the companion.
+ */
+export function isForbiddenCompanionTool(toolName) {
+    const norm = toolName.trim().toLowerCase();
+    for (const pattern of COMPANION_FORBIDDEN_PATTERNS) {
+        if (typeof pattern === 'string') {
+            if (norm === pattern.toLowerCase())
+                return true;
+        }
+        else if (pattern instanceof RegExp) {
+            if (pattern.test(norm))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if companion tools are enabled via circuit-breaker.
+ * Default is FALSE (OFF).
+ */
+export function isCompanionToolsEnabled(env = process.env) {
+    const raw = (env.CODEBUDDY_COMPANION_TOOLS_ENABLED ?? '').trim().toLowerCase();
+    return raw === 'true' || raw === '1' || raw === 'yes' || raw === 'on';
+}
+/**
+ * Resolve allowed tool names for a given identity and environment.
+ */
+export function getCompanionToolNames(identity, env = process.env) {
+    // 1. Circuit breaker OFF -> zero tools
+    if (!isCompanionToolsEnabled(env)) {
+        return [];
+    }
+    // 2. Guest role -> zero tools (fail-closed)
+    if (identity.role === 'guest') {
+        return [];
+    }
+    // 3. Baseline per role
+    const baseline = identity.role === 'owner' ? OWNER_COMPANION_TOOLS : PRESENT_COMPANION_TOOLS;
+    // 4. Surcharge via CODEBUDDY_COMPANION_TOOLS (CSV)
+    // Hard invariant: CSV can ONLY INTERSECT the role's baseline tools, NEVER extend it.
+    let allowed;
+    const configured = (env.CODEBUDDY_COMPANION_TOOLS ?? '').trim();
+    if (configured) {
+        const requested = new Set(configured
+            .split(',')
+            .map((s) => s.trim().toLowerCase())
+            .filter(Boolean));
+        // Strict intersection with role baseline (order preserved from baseline)
+        allowed = baseline.filter((tool) => {
+            const match = requested.has(tool.toLowerCase());
+            if (!match)
+                return false;
+            if (isForbiddenCompanionTool(tool)) {
+                logger.warn(`[companion-toolset] Surcharge tool "${tool}" rejected: strictly forbidden`);
+                return false;
+            }
+            return true;
+        });
+    }
+    else {
+        allowed = [...baseline];
+    }
+    // Final sanity filter: eliminate any forbidden tool that could have leaked
+    return allowed.filter((tool) => !isForbiddenCompanionTool(tool));
+}
+/**
+ * Human-friendly waiting phrase when a slow tool starts executing.
+ */
+export function getCompanionToolWaitingWord(toolName) {
+    switch (toolName) {
+        case 'image_generate':
+            return 'Je dessine…';
+        case 'image_edit':
+            return 'Je modifie l’image…';
+        case 'camera_analyze':
+        case 'camera_snapshot':
+            return 'Je regarde…';
+        case 'web_search':
+            return 'Je cherche sur le web…';
+        case 'weather':
+            return 'Je regarde la météo…';
+        case 'stock_quote':
+            return 'Je vérifie les cours de bourse…';
+        case 'understand_video':
+            return 'J’analyse la vidéo…';
+        case 'remind':
+            return 'Je note ton rappel…';
+        case 'recall':
+            return 'Je vérifie dans mes souvenirs…';
+        default:
+            return null;
+    }
+}
+/**
+ * Get OpenAI-compatible function tool definitions for allowed companion tools.
+ */
+export async function getCompanionToolDefinitions(identity, options = {}) {
+    const env = options.env ?? process.env;
+    const toolNames = getCompanionToolNames(identity, env);
+    if (toolNames.length === 0)
+        return [];
+    const registry = options.registry ?? FormalToolRegistry.getInstance();
+    if (registry.getNames().length === 0) {
+        const { registerBuiltinTools } = await import('../tools/registry/index.js');
+        registerBuiltinTools(registry);
+    }
+    const definitions = [];
+    for (const name of toolNames) {
+        const registered = registry.get(name);
+        if (!registered) {
+            continue;
+        }
+        const schema = registered.tool.getSchema();
+        definitions.push({
+            type: 'function',
+            function: {
+                name: schema.name,
+                description: schema.description,
+                parameters: {
+                    type: 'object',
+                    properties: schema.parameters?.properties ?? {},
+                    required: schema.parameters?.required ?? [],
+                    ...(schema.parameters?.additionalProperties !== undefined
+                        ? { additionalProperties: schema.parameters.additionalProperties }
+                        : {}),
+                },
+            },
+        });
+    }
+    return definitions;
+}
+/**
+ * Safely execute a companion tool call.
+ */
+export async function executeCompanionTool(toolName, args, context) {
+    const env = context.env ?? process.env;
+    // 1. Hard invariant: forbidden tool
+    if (isForbiddenCompanionTool(toolName)) {
+        const err = `Tool "${toolName}" is strictly forbidden in companion mode.`;
+        logger.warn(`[companion-toolset] ${err}`);
+        return { success: false, error: err };
+    }
+    // 2. Authorization check against identity role
+    const allowedNames = getCompanionToolNames(context.identity, env);
+    if (!allowedNames.includes(toolName)) {
+        const err = `Tool "${toolName}" is not permitted for companion identity role "${context.identity.role}".`;
+        logger.warn(`[companion-toolset] ${err}`);
+        return { success: false, error: err };
+    }
+    // 3. Confirmation gate:
+    // Destructive tools are blocked by isForbiddenCompanionTool.
+    // For permitted companion read/generation tools, validate against policy engine kill-switch
+    // and honor any explicit confirmationService passed in context.
+    if (context.confirmationService) {
+        const confirmationRes = await context.confirmationService.requestConfirmation({
+            operation: `companion:${toolName}`,
+            filename: toolName,
+            toolName,
+            toolArgs: args,
+            showVSCodeOpen: false,
+            content: `Companion tool: ${toolName}\nArguments:\n${JSON.stringify(args, null, 2)}`,
+        }, 'tool');
+        if (!confirmationRes.confirmed) {
+            return {
+                success: false,
+                error: confirmationRes.feedback ?? `Execution of "${toolName}" was rejected by confirmation policy.`,
+            };
+        }
+    }
+    else {
+        const { PolicyEngine } = await import('../security/policy-engine.js');
+        if (PolicyEngine.getInstance().isKilled()) {
+            return {
+                success: false,
+                error: `Security kill-switch active: ${PolicyEngine.getInstance().getKillReason()}`,
+            };
+        }
+    }
+    // 4. Retrieve tool from registry
+    const registry = context.registry ?? FormalToolRegistry.getInstance();
+    if (registry.getNames().length === 0) {
+        const { registerBuiltinTools } = await import('../tools/registry/index.js');
+        registerBuiltinTools(registry);
+    }
+    const registered = registry.get(toolName);
+    if (!registered) {
+        return {
+            success: false,
+            error: `Companion tool "${toolName}" is not registered in the tool registry.`,
+        };
+    }
+    // 5. Execute
+    try {
+        return await registered.tool.execute(args, {
+            cwd: context.cwd ?? process.cwd(),
+            abortSignal: context.signal,
+        });
+    }
+    catch (execError) {
+        const msg = execError instanceof Error ? execError.message : String(execError);
+        logger.warn(`[companion-toolset] Error executing tool "${toolName}": ${msg}`);
+        return {
+            success: false,
+            error: `Tool execution error: ${msg}`,
+        };
+    }
+}
+/**
+ * Extract image path from tool execution result if one was created/returned.
+ */
+export function extractImagePathFromToolResult(result, cwd = process.cwd()) {
+    if (!result || !result.success)
+        return undefined;
+    const isImagePath = (val) => {
+        if (typeof val !== 'string' || !val.trim())
+            return false;
+        const clean = val.trim();
+        return /\.(png|jpe?g|webp)$/i.test(clean);
+    };
+    const toAbs = (filePath) => {
+        return path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+    };
+    const data = result.data;
+    if (data && typeof data === 'object') {
+        if (isImagePath(data.mediaPath))
+            return toAbs(data.mediaPath);
+        if (isImagePath(data.imagePath))
+            return toAbs(data.imagePath);
+        if (isImagePath(data.outputPath))
+            return toAbs(data.outputPath);
+        if (isImagePath(data.path))
+            return toAbs(data.path);
+        if (isImagePath(data.image))
+            return toAbs(data.image);
+        if (Array.isArray(data.images) && isImagePath(data.images[0]?.path)) {
+            return toAbs(data.images[0].path);
+        }
+    }
+    // Fallback: check output string if JSON
+    if (typeof result.output === 'string') {
+        try {
+            const parsed = JSON.parse(result.output);
+            if (parsed && typeof parsed === 'object') {
+                if (isImagePath(parsed.mediaPath))
+                    return toAbs(parsed.mediaPath);
+                if (isImagePath(parsed.imagePath))
+                    return toAbs(parsed.imagePath);
+                if (isImagePath(parsed.outputPath))
+                    return toAbs(parsed.outputPath);
+                if (isImagePath(parsed.path))
+                    return toAbs(parsed.path);
+                if (isImagePath(parsed.image))
+                    return toAbs(parsed.image);
+            }
+        }
+        catch {
+            // not JSON
+        }
+        // Search for an absolute POSIX or Windows image path in human-readable output.
+        const match = result.output.match(/(?:^|[\s"'`])((?:[a-z]:[\\/]|\/)[^\s"'`]+\.(?:png|jpe?g|webp))/i);
+        if (match && match[1]) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=companion-toolset.js.map

package/dist/companion/companion-turn.d.ts

@@ -31,6 +31,7 @@ import type { CompanionSelfieServeResult, CompanionSelfieSurface, TryServeCompan
 /** A companion surface. `voice` keeps its own loop; it is listed for symmetry. */
 export type CompanionSurface = CompanionSelfieSurface;
 export type { CompanionHistoryTurn } from './companion-history.js';
+import { type CompanionIdentity } from './companion-identity.js';
 export interface CompanionTurnResult {
     text: string;
     kind: 'selfie' | 'text';
@@ -40,6 +41,8 @@ export interface CompanionTurnResult {
     };
     imagePath?: string;
     model?: string;
+    historySuffix?: string;
+    executedTools?: import('../channels/companion-channel-turn.js').CompanionExecutedTool[];
     /** Present only when the user shared photos in this turn. */
     photos?: {
         /** Where the image went. `local` means the bytes never left the machine. */
@@ -60,6 +63,11 @@ export interface RunCompanionTurnOptions {
     history?: CompanionHistoryTurn[];
     env?: NodeJS.ProcessEnv;
     signal?: AbortSignal;
+    /** Explicit identity of the user, or resolved from surface and IDs */
+    identity?: CompanionIdentity;
+    userId?: string;
+    chatId?: string;
+    onWaitingWord?: (word: string) => Promise<void> | void;
     /**
      * Photos the user shared with this message. Absent (the default) the turn is
      * byte-identical to a text-only turn: no photo module is even imported.
@@ -70,11 +78,11 @@ export interface RunCompanionTurnOptions {
     /** Injectables — production resolves each of these itself. */
     resolveProvider?: (env: NodeJS.ProcessEnv) => CompanionTurnProvider | null;
     serveSelfie?: (text: string, options: TryServeCompanionSelfieOptions) => Promise<CompanionSelfieServeResult | null>;
-    chat?: (messages: CodeBuddyMessage[], tools: [], opts: {
+    chat?: (messages: CodeBuddyMessage[], tools: unknown[], opts: {
         model: string;
         maxTokens?: number;
         signal?: AbortSignal;
-        tool_choice: 'none';
+        tool_choice?: unknown;
     }) => Promise<CodeBuddyResponse>;
     /** Photo seams — production uses the real pipeline and the real album. */
     preparePhotos?: typeof prepareCompanionPhotos;

package/dist/companion/companion-turn.js

@@ -32,6 +32,7 @@ import { attachPhotoParts, looksLikeVisionRefusal, prepareCompanionPhotos, } fro
 import { rememberSharedPhotos } from './shared-photo-memory.js';
 import { applyLimitsContract } from './reply-augment.js';
 import { guardRelationshipReply } from '../conversation/relationship-safety.js';
+import { resolveCompanionIdentity } from './companion-identity.js';
 /** Fallback when no provider is configured — spoken, never a silent empty reply. */
 const NO_PROVIDER_MESSAGE = 'unreachable: no configured provider for the companion turn';
 export { historyHasRecentSelfie } from './companion-history.js';
@@ -132,6 +133,13 @@ export async function runCompanionTurn(message, options) {
     const messagesFor = (batch, base) => batch && batch.mode === 'cloud' && batch.photos.length > 0
         ? attachPhotoParts(base, batch.photos)
         : base;
+    const identity = options.identity ??
+        resolveCompanionIdentity({
+            channel: options.surface === 'mobile' ? 'pwa' : options.surface,
+            userId: options.userId,
+            chatId: options.chatId,
+            env,
+        });
     try {
         let batch = prepared;
         let generated = await runCompanionChannelTurn({
@@ -139,6 +147,10 @@ export async function runCompanionTurn(message, options) {
             baseUrl: provider.baseUrl,
             model: provider.model,
             messages: messagesFor(batch, prompt.messages),
+            identity,
+            surface: options.surface,
+            env,
+            ...(options.onWaitingWord ? { onWaitingWord: options.onWaitingWord } : {}),
             ...(options.signal ? { signal: options.signal } : {}),
             ...(options.chat ? { chat: options.chat } : {}),
         });
@@ -168,6 +180,10 @@ export async function runCompanionTurn(message, options) {
                     baseUrl: provider.baseUrl,
                     model: provider.model,
                     messages: localPrompt.messages,
+                    identity,
+                    surface: options.surface,
+                    env,
+                    ...(options.onWaitingWord ? { onWaitingWord: options.onWaitingWord } : {}),
                     ...(options.signal ? { signal: options.signal } : {}),
                     ...(options.chat ? { chat: options.chat } : {}),
                 });
@@ -184,10 +200,31 @@ export async function runCompanionTurn(message, options) {
         }
         const guarded = guardRelationshipReply(text);
         const limited = applyLimitsContract(guarded.response, { heard: message, env });
+        const firstMedia = generated.media?.[0];
+        let generatedImage;
+        if (firstMedia?.imagePath && (options.includeImageBytes === true || options.surface === 'mobile')) {
+            try {
+                const fsMod = await import('fs/promises');
+                const pathMod = await import('path');
+                const ext = pathMod.extname(firstMedia.imagePath).slice(1).toLowerCase();
+                const mimeType = ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : `image/${ext || 'png'}`;
+                const data = (await fsMod.readFile(firstMedia.imagePath)).toString('base64');
+                generatedImage = { mimeType, data };
+            }
+            catch (readErr) {
+                logger.warn('[companion-turn] Failed to read generated media bytes', {
+                    error: readErr instanceof Error ? readErr.message : String(readErr),
+                });
+            }
+        }
         return {
             text: prependUserFacingFailoverNotice(limited.text, 'companion-turn'),
-            kind: 'text',
+            kind: firstMedia ? 'selfie' : 'text',
+            ...(firstMedia?.imagePath ? { imagePath: firstMedia.imagePath } : {}),
+            ...(generatedImage ? { image: generatedImage } : {}),
             model: generated.model,
+            ...(generated.historySuffix ? { historySuffix: generated.historySuffix } : {}),
+            ...(generated.executedTools ? { executedTools: generated.executedTools } : {}),
             ...(photoSummary ? { photos: photoSummary } : {}),
         };
     }

package/dist/config/code-exec-policy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Programmatic tool calling (`code_exec`) policy per model (comparatif plan P5).
+ *
+ * - `offer` (default, unchanged behaviour): `code_exec` is selected by relevance
+ *   or when the user explicitly asks for programmatic tool calling.
+ * - `prefer`: `code_exec` is always offered and the model gets a short hint to
+ *   batch multi-step reads/computations into one program.
+ * - `off`: `code_exec` is never offered, even on explicit request; the model is
+ *   told why through the runtime settings snapshot.
+ *
+ * Promotion rule: NO model ships with `prefer`. A `prefer` entry in
+ * `model-tools.ts` must carry `codeExecEvidence` (a Buddy recette report proving
+ * ADV01–ADV09 on that model). Other projects' "preferred" lists are not evidence.
+ * `CODEBUDDY_CODE_EXEC_POLICY` is an explicit operator override for trials.
+ */
+export type CodeExecPolicy = 'off' | 'offer' | 'prefer';
+export interface ResolvedCodeExecPolicy {
+    policy: CodeExecPolicy;
+    source: 'env' | 'model' | 'default';
+    evidence?: string;
+}
+export declare function isCodeExecPolicy(value: unknown): value is CodeExecPolicy;
+export declare function resolveCodeExecPolicy(model: string | undefined): ResolvedCodeExecPolicy;
+export declare const CODE_EXEC_PREFER_HINT = "Programmatic tool calling is preferred for this model: when a task needs several reads, searches or computations whose results feed each other, run them in ONE code_exec program (tools.call) instead of many separate tool rounds. Keep single-step tasks as direct tool calls.";
+export declare const CODE_EXEC_OFF_NOTICE = "Programmatic tool calling (code_exec) is disabled by the model policy for this model. If the user asks for code_exec or tools.call, say that it is disabled for this model and use direct tool calls instead.";

package/dist/config/code-exec-policy.js

@@ -0,0 +1,39 @@
+/**
+ * Programmatic tool calling (`code_exec`) policy per model (comparatif plan P5).
+ *
+ * - `offer` (default, unchanged behaviour): `code_exec` is selected by relevance
+ *   or when the user explicitly asks for programmatic tool calling.
+ * - `prefer`: `code_exec` is always offered and the model gets a short hint to
+ *   batch multi-step reads/computations into one program.
+ * - `off`: `code_exec` is never offered, even on explicit request; the model is
+ *   told why through the runtime settings snapshot.
+ *
+ * Promotion rule: NO model ships with `prefer`. A `prefer` entry in
+ * `model-tools.ts` must carry `codeExecEvidence` (a Buddy recette report proving
+ * ADV01–ADV09 on that model). Other projects' "preferred" lists are not evidence.
+ * `CODEBUDDY_CODE_EXEC_POLICY` is an explicit operator override for trials.
+ */
+import { getModelToolConfig } from './model-tools.js';
+const POLICIES = new Set(['off', 'offer', 'prefer']);
+export function isCodeExecPolicy(value) {
+    return typeof value === 'string' && POLICIES.has(value);
+}
+export function resolveCodeExecPolicy(model) {
+    const override = process.env.CODEBUDDY_CODE_EXEC_POLICY?.trim().toLowerCase();
+    if (isCodeExecPolicy(override))
+        return { policy: override, source: 'env' };
+    if (model) {
+        const config = getModelToolConfig(model);
+        if (isCodeExecPolicy(config.codeExec)) {
+            return {
+                policy: config.codeExec,
+                source: 'model',
+                ...(config.codeExecEvidence ? { evidence: config.codeExecEvidence } : {}),
+            };
+        }
+    }
+    return { policy: 'offer', source: 'default' };
+}
+export const CODE_EXEC_PREFER_HINT = 'Programmatic tool calling is preferred for this model: when a task needs several reads, searches or computations whose results feed each other, run them in ONE code_exec program (tools.call) instead of many separate tool rounds. Keep single-step tasks as direct tool calls.';
+export const CODE_EXEC_OFF_NOTICE = 'Programmatic tool calling (code_exec) is disabled by the model policy for this model. If the user asks for code_exec or tools.call, say that it is disabled for this model and use direct tool calls instead.';
+//# sourceMappingURL=code-exec-policy.js.map

package/dist/config/model-tools.d.ts

@@ -54,6 +54,13 @@ export interface ModelToolConfig {
      *     full instruction set.
      */
     promptProfile?: 'lite' | 'standard' | 'rich';
+    /**
+     * Programmatic tool calling policy (P5, `src/config/code-exec-policy.ts`).
+     * Absent = `offer` (historical behaviour). `prefer` requires `codeExecEvidence`.
+     */
+    codeExec?: 'off' | 'offer' | 'prefer';
+    /** Path of the Buddy recette report (ADV01–ADV09) that justifies `codeExec: 'prefer'`. */
+    codeExecEvidence?: string;
 }
 /**
  * Nom « nu » d'un modèle : sans préfixe fournisseur (`moonshotai/kimi-k3` → `kimi-k3`) ni tag
@@ -81,6 +88,8 @@ export declare function resetRuntimeModelContextCache(): void;
  * décrits ici sans les dupliquer dans `SUPPORTED_MODELS`.
  */
 export declare function findModelToolConfig(modelName: string, customConfigs?: ModelToolConfig[]): ModelToolConfig | null;
+/** Read-only view of the built-in table (consistency tests, e.g. P5 `codeExecEvidence`). */
+export declare function listDefaultModelToolConfigs(): readonly Readonly<ModelToolConfig>[];
 export declare function getModelToolConfig(modelName: string, customConfigs?: ModelToolConfig[]): ModelToolConfig;
 /** Test seam — clear the strengths memo. */
 export declare function resetModelStrengthsCache(): void;

package/dist/config/model-tools.js

@@ -1169,6 +1169,10 @@ export function resetRuntimeModelContextCache() {
 export function findModelToolConfig(modelName, customConfigs) {
     return findConfigMatch(modelName, [...(customConfigs || []), ...DEFAULT_MODEL_CONFIGS])?.config ?? null;
 }
+/** Read-only view of the built-in table (consistency tests, e.g. P5 `codeExecEvidence`). */
+export function listDefaultModelToolConfigs() {
+    return DEFAULT_MODEL_CONFIGS.map((config) => Object.freeze({ ...config }));
+}
 export function getModelToolConfig(modelName, customConfigs) {
     // Use cache for default config lookups (hot path)
     if (!customConfigs && _configCache.has(modelName)) {

package/dist/context/context-manager-v2.js

@@ -12,6 +12,7 @@
  * - Content-type-aware Compression
  * - Key Information Preservation
  */
+import { truncateOutput } from '../utils/bounded-output.js';
 import { createHash } from 'node:crypto';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -703,8 +704,7 @@ export class ContextManagerV2 {
                 if (msg.content.length > MAX_TOOL_RESULT_LENGTH) {
                     return {
                         ...msg,
-                        content: msg.content.substring(0, MAX_TOOL_RESULT_LENGTH) +
-                            '\n... [truncated for context limits]',
+                        content: truncateOutput(msg.content, MAX_TOOL_RESULT_LENGTH),
                     };
                 }
             }

package/dist/context/lm-resizer-compressor.js

@@ -44,8 +44,9 @@ function stringArray(value) {
 /** Resolve lm-resizer: explicit env -> stable install -> PATH -> mutable DEV build. */
 export function resolveLmResizerBin() {
     const env = process.env.CODEBUDDY_LM_RESIZER_BIN;
-    if (env && existsSync(env))
-        return env;
+    // An explicit choice must not silently fall through to an older binary.
+    if (env?.trim())
+        return env.trim();
     const stable = join(homedir(), '.local', 'bin', 'lm-resizer');
     if (existsSync(stable))
         return stable;

package/dist/context/lm-resizer-diagnostics.d.ts

@@ -0,0 +1,9 @@
+/** Read-only host probe. Availability alone does not establish protocol support. */
+export declare function diagnoseLmResizer(): Promise<{
+    binary: string;
+    enabled: boolean;
+    available: boolean;
+    toolOutputSupported: boolean;
+    version: string;
+    warning: string;
+}>;

package/dist/context/lm-resizer-diagnostics.js

@@ -0,0 +1,30 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { isLmResizerEnabled, resolveLmResizerBin } from './lm-resizer-compressor.js';
+const run = promisify(execFile);
+/** Read-only host probe. Availability alone does not establish protocol support. */
+export async function diagnoseLmResizer() {
+    const binary = resolveLmResizerBin();
+    const result = { binary, enabled: isLmResizerEnabled(), available: false, toolOutputSupported: false, version: 'unknown', warning: '' };
+    const options = { timeout: 3000, maxBuffer: 64 * 1024, windowsHide: true };
+    try {
+        await run(binary, ['--help'], options);
+        result.available = true;
+        try {
+            result.version = (await run(binary, ['--version'], options)).stdout.trim();
+        }
+        catch { /* Older CLI has no version flag. */ }
+        try {
+            const probe = await run(binary, ['tool-output', '--help'], options);
+            result.toolOutputSupported = /tool-output/.test(probe.stdout);
+        }
+        catch { /* Old protocol: retain raw observations. */ }
+        if (!result.toolOutputSupported)
+            result.warning = 'This binary lacks the tool-output protocol. Buddy keeps raw observations; install a compatible release to enable observation compression.';
+    }
+    catch {
+        result.warning = 'LM Resizer is unavailable on the host. Buddy keeps raw observations.';
+    }
+    return result;
+}
+//# sourceMappingURL=lm-resizer-diagnostics.js.map