@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/tools/media-generation-tool.js

@@ -5,6 +5,9 @@ import path from 'path';
 import { getImageGenerationModel } from '../config/agent-defaults.js';
 import { resolveToolGatewayRoute } from '../agent/tool-gateway-router.js';
 import { logger } from '../utils/logger.js';
+import { getChatGptAuth, hasCodexCredentials, refreshChatGptAuth, } from '../providers/codex-oauth.js';
+import { buildChatGptHeaders, CHATGPT_RESPONSES_URL, } from '../codebuddy/providers/chatgpt-headers.js';
+import { CHATGPT_OAUTH_DEFAULT_MODEL } from '../providers/chatgpt-models.js';
 const IMAGE_SIZES = {
     landscape: '1536x1024',
     square: '1024x1024',
@@ -38,7 +41,7 @@ export async function generateImage(input, runtime = {}) {
     if (!prompt) {
         throw new Error('prompt is required for image generation');
     }
-    const config = resolveImageProvider(runtime.env ?? process.env);
+    const config = resolveImageProvider(runtime.env ?? process.env, { hasAuthOverride: Boolean(runtime.chatGptAuth) });
     const aspect = resolveImageAspect(input.aspectRatio);
     const fetchImpl = runtime.fetch ?? fetch;
     const generatedAt = (runtime.now ?? (() => new Date()))().toISOString();
@@ -48,6 +51,9 @@ export async function generateImage(input, runtime = {}) {
         await ingestLisaSelfieIfNeeded(comfy, runtime);
         return comfy;
     }
+    if (config.provider === 'chatgpt') {
+        return generateChatGptImage(prompt, aspect, config, runtime, generatedAt);
+    }
     const size = IMAGE_SIZES[aspect];
     const body = {
         model: config.model,
@@ -155,7 +161,7 @@ export async function editImage(input, runtime = {}) {
     const imageUrl = validateImageReference(input.imageUrl, 'source image');
     const selections = normalizeEditSelections(input.selections);
     const maskUrl = input.maskUrl ? validateDataImage(input.maskUrl, 'mask') : undefined;
-    const config = resolveImageProvider(runtime.env ?? process.env);
+    const config = resolveImageProvider(runtime.env ?? process.env, { hasAuthOverride: Boolean(runtime.chatGptAuth) });
     const fetchImpl = runtime.fetch ?? fetch;
     const generatedAt = (runtime.now ?? (() => new Date()))().toISOString();
     const selectionHint = selections.length > 0
@@ -174,6 +180,15 @@ export async function editImage(input, runtime = {}) {
             sourceRef: input.sourceRef,
         }, config, runtime, generatedAt);
     }
+    if (config.provider === 'chatgpt') {
+        return editChatGptImage({
+            prompt,
+            effectivePrompt,
+            imageUrl,
+            selections,
+            sourceRef: input.sourceRef,
+        }, config, runtime, generatedAt);
+    }
     let response;
     if (config.provider === 'xai') {
         response = await postJson(fetchImpl, joinUrl(config.baseUrl, '/images/edits'), {
@@ -264,6 +279,299 @@ export async function editImage(input, runtime = {}) {
         ...(revisedPrompt ? { revised_prompt: revisedPrompt } : {}),
     };
 }
+// ---------------------------------------------------------------------------
+// ChatGPT Codex image backend ($0 subscription, gpt-image-2 via /responses).
+// ---------------------------------------------------------------------------
+export function parseChatGptImageResponse(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.error?.message) {
+                throw new Error(`ChatGPT error: ${parsed.error.message}`);
+            }
+            if (Array.isArray(parsed.data) && parsed.data[0]?.b64_json) {
+                return {
+                    b64: parsed.data[0].b64_json,
+                    revisedPrompt: parsed.data[0].revised_prompt,
+                };
+            }
+            if (parsed.item?.type === 'image_generation_call' && parsed.item.result) {
+                return {
+                    b64: parsed.item.result,
+                    revisedPrompt: parsed.item.revised_prompt,
+                };
+            }
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith('ChatGPT'))
+                throw e;
+        }
+    }
+    let b64;
+    let revisedPrompt;
+    const lines = text.split('\n');
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line.startsWith('data:'))
+            continue;
+        const dataStr = line.slice(5).trim();
+        if (!dataStr || dataStr === '[DONE]')
+            continue;
+        try {
+            const event = JSON.parse(dataStr);
+            if (event.error?.message) {
+                throw new Error(`ChatGPT image error: ${event.error.message}`);
+            }
+            if (event.type === 'response.failed' && event.response?.error?.message) {
+                throw new Error(`ChatGPT image response failed: ${event.response.error.message}`);
+            }
+            if (event.item?.type === 'image_generation_call') {
+                if (event.item.result)
+                    b64 = event.item.result;
+                if (event.item.revised_prompt)
+                    revisedPrompt = event.item.revised_prompt;
+            }
+            else if (Array.isArray(event.data) && event.data[0]?.b64_json) {
+                b64 = event.data[0].b64_json;
+                if (event.data[0].revised_prompt)
+                    revisedPrompt = event.data[0].revised_prompt;
+            }
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith('ChatGPT'))
+                throw e;
+        }
+    }
+    if (!b64) {
+        throw new Error('ChatGPT image generation response did not contain image data');
+    }
+    return { b64, revisedPrompt };
+}
+async function executeChatGptResponsesImage(options) {
+    const { prompt, imageUrl, config, runtime, timeoutMs } = options;
+    const fetchImpl = runtime.fetch ?? fetch;
+    const envSource = runtime.env ?? process.env;
+    let auth = runtime.chatGptAuth;
+    if (!auth) {
+        try {
+            auth = (await getChatGptAuth()) ?? undefined;
+        }
+        catch {
+            // getChatGptAuth may throw or return null
+        }
+    }
+    if (!auth?.access_token) {
+        throw new Error('No ChatGPT credentials found for provider chatgpt. Run `buddy login` (or `/login chatgpt`) to connect.');
+    }
+    const endpoint = config.baseUrl;
+    const isDirectImageEndpoint = endpoint.includes('/images/');
+    let requestBody;
+    if (isDirectImageEndpoint) {
+        requestBody = {
+            model: config.model,
+            prompt,
+            ...(imageUrl ? { image: imageUrl } : {}),
+        };
+    }
+    else {
+        const conversationalModel = env(envSource, 'CODEBUDDY_CHATGPT_MODEL') ?? CHATGPT_OAUTH_DEFAULT_MODEL;
+        const content = [
+            { type: 'input_text', text: prompt },
+        ];
+        if (imageUrl) {
+            content.push({ type: 'input_image', image_url: imageUrl });
+        }
+        requestBody = {
+            model: conversationalModel,
+            store: false,
+            stream: true,
+            instructions: 'You are an image generation assistant. When the user asks to generate or edit an image, invoke the image_generation tool immediately with the prompt and any provided input image.',
+            input: [
+                {
+                    type: 'message',
+                    role: 'user',
+                    content,
+                },
+            ],
+            tools: [
+                {
+                    type: 'image_generation',
+                    // The Codex backend honours a per-tool model (verified live 2026-09-10):
+                    // Images 2.5 (`gpt-image-2.5-flare` by default) instead of the backend default.
+                    model: config.model,
+                },
+            ],
+        };
+    }
+    let res;
+    try {
+        res = await fetchWithTimeout(fetchImpl, endpoint, {
+            method: 'POST',
+            headers: buildChatGptHeaders(auth, {
+                accept: isDirectImageEndpoint ? 'application/json' : 'text/event-stream',
+            }),
+            body: JSON.stringify(requestBody),
+        }, timeoutMs, runtime.signal);
+    }
+    catch (err) {
+        if (runtime.signal?.aborted)
+            throw err;
+        throw new Error(`ChatGPT image generation network error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (res.status === 401) {
+        try {
+            const refreshed = await refreshChatGptAuth();
+            if (refreshed?.access_token) {
+                auth = refreshed;
+                res = await fetchWithTimeout(fetchImpl, endpoint, {
+                    method: 'POST',
+                    headers: buildChatGptHeaders(auth, {
+                        accept: isDirectImageEndpoint ? 'application/json' : 'text/event-stream',
+                    }),
+                    body: JSON.stringify(requestBody),
+                }, timeoutMs, runtime.signal);
+            }
+        }
+        catch {
+            // Refresh failed, proceed to status checks
+        }
+    }
+    if (res.status === 401) {
+        throw new Error('ChatGPT authentication expired (401). Please run `buddy login` (or `/login chatgpt`) to reconnect.');
+    }
+    if (res.status === 429) {
+        const errText = await res.text().catch(() => '');
+        let message = 'ChatGPT image generation rate limit reached (429). Please wait before requesting another image.';
+        try {
+            const parsed = JSON.parse(errText);
+            if (parsed.error?.message) {
+                message = `ChatGPT image generation rate limit reached (429): ${parsed.error.message}`;
+            }
+        }
+        catch {
+            // ignore JSON parse error
+        }
+        throw new Error(message);
+    }
+    if (!res.ok) {
+        const errText = await res.text().catch(() => '');
+        let message = `ChatGPT image generation failed with status ${res.status}`;
+        try {
+            const parsed = JSON.parse(errText);
+            if (parsed.error?.message) {
+                message += `: ${parsed.error.message}`;
+            }
+            else if (errText) {
+                message += `: ${errText}`;
+            }
+        }
+        catch {
+            if (errText)
+                message += `: ${errText}`;
+        }
+        throw new Error(message);
+    }
+    const responseText = await res.text();
+    return parseChatGptImageResponse(responseText);
+}
+async function generateChatGptImage(prompt, aspect, config, runtime, generatedAt) {
+    const envSource = runtime.env ?? process.env;
+    const timeoutMs = Number(envSource.CODEBUDDY_CHATGPT_IMAGE_TIMEOUT_MS) || 180_000;
+    const aspectHint = aspect === 'square'
+        ? ' (aspect ratio: square 1:1)'
+        : aspect === 'portrait'
+            ? ' (aspect ratio: portrait 2:3)'
+            : ' (aspect ratio: landscape 3:2)';
+    const effectivePrompt = `${prompt}${aspectHint}`;
+    const { b64, revisedPrompt } = await executeChatGptResponsesImage({
+        prompt: effectivePrompt,
+        config,
+        runtime,
+        timeoutMs,
+    });
+    const bytes = Buffer.from(b64, 'base64');
+    const outputPath = await saveGeneratedAsset(bytes, {
+        rootDir: runtime.rootDir,
+        dirName: 'images',
+        prefix: 'image',
+        extension: 'png',
+        createId: runtime.createId,
+    });
+    await writeMediaSidecar(outputPath, {
+        kind: 'image',
+        prompt,
+        ...(revisedPrompt ? { revisedPrompt } : {}),
+        provider: config.provider,
+        model: config.model,
+        aspect_ratio: aspect,
+        generatedAt,
+    });
+    const result = {
+        kind: 'image_generate_result',
+        success: true,
+        image: outputPath,
+        outputPath,
+        mediaPath: `MEDIA:${outputPath}`,
+        provider: config.provider,
+        model: config.model,
+        prompt,
+        aspect_ratio: aspect,
+        generatedAt,
+        ...(revisedPrompt ? { revised_prompt: revisedPrompt } : {}),
+    };
+    await ingestLisaSelfieIfNeeded(result, runtime);
+    return result;
+}
+async function editChatGptImage(input, config, runtime, generatedAt) {
+    const envSource = runtime.env ?? process.env;
+    const timeoutMs = Number(envSource.CODEBUDDY_CHATGPT_IMAGE_TIMEOUT_MS) || 180_000;
+    const { b64, revisedPrompt } = await executeChatGptResponsesImage({
+        prompt: input.effectivePrompt,
+        imageUrl: input.imageUrl,
+        config,
+        runtime,
+        timeoutMs,
+    });
+    const bytes = Buffer.from(b64, 'base64');
+    const outputPath = await saveGeneratedAsset(bytes, {
+        rootDir: runtime.rootDir,
+        dirName: 'images',
+        prefix: 'image-edit',
+        extension: 'png',
+        createId: runtime.createId,
+    });
+    const maskMode = input.selections.length > 0 ? 'region-prompt' : 'none';
+    const sourceReference = sanitizeImageSourceReference(input.sourceRef) ?? redactDataUrl(input.imageUrl);
+    await writeMediaSidecar(outputPath, {
+        kind: 'image-edit',
+        prompt: input.prompt,
+        ...(revisedPrompt ? { revisedPrompt } : {}),
+        provider: config.provider,
+        model: config.model,
+        source: sourceReference,
+        masked: false,
+        maskMode,
+        selections: input.selections,
+        generatedAt,
+    });
+    return {
+        kind: 'image_edit_result',
+        success: true,
+        image: outputPath,
+        outputPath,
+        mediaPath: `MEDIA:${outputPath}`,
+        provider: config.provider,
+        model: config.model,
+        prompt: input.prompt,
+        source: sourceReference,
+        masked: false,
+        maskMode,
+        selections: input.selections,
+        generatedAt,
+        ...(revisedPrompt ? { revised_prompt: revisedPrompt } : {}),
+    };
+}
 const COMFY_DIMS = {
     landscape: { width: 1024, height: 768 },
     square: { width: 768, height: 768 },
@@ -525,13 +833,16 @@ function comfyDelay(ms, signal) {
     });
 }
 export async function getImageEditCapabilities(runtime = {}) {
-    const config = resolveImageProvider(runtime.env ?? process.env);
+    const config = resolveImageProvider(runtime.env ?? process.env, { hasAuthOverride: Boolean(runtime.chatGptAuth) });
     if (config.provider === 'openai') {
         return { provider: config.provider, available: true, alphaMasking: true };
     }
     if (config.provider === 'xai') {
         return { provider: config.provider, available: true, alphaMasking: false };
     }
+    if (config.provider === 'chatgpt') {
+        return { provider: config.provider, available: true, alphaMasking: false };
+    }
     if (config.provider !== 'comfyui') {
         return { provider: config.provider, available: false, alphaMasking: false, reason: 'Provider does not support image editing' };
     }
@@ -1483,7 +1794,7 @@ async function materializeVideoResult(videoUrl, options) {
         ...(options.endpoint ? { endpoint: options.endpoint } : {}),
     };
 }
-function resolveImageProvider(envSource) {
+export function resolveImageProvider(envSource = process.env, options) {
     let requested = (envSource.CODEBUDDY_IMAGE_PROVIDER ?? '').trim().toLowerCase();
     // Prefer ComfyUI when explicitly requested OR when a ComfyUI endpoint is
     // declared and no other provider was chosen (selfie / local-first companion
@@ -1498,6 +1809,13 @@ function resolveImageProvider(envSource) {
             || declaredFallbacks.length > 0)) {
         requested = 'comfyui';
     }
+    const hasOpenAiKey = Boolean(envSource.OPENAI_API_KEY?.trim() || envSource.CODEBUDDY_IMAGE_API_KEY?.trim());
+    const hasXaiKey = Boolean(envSource.XAI_API_KEY?.trim());
+    const hasFalKey = Boolean(envSource.FAL_KEY?.trim() || envSource.FAL_API_KEY?.trim());
+    const hasChatGptAuth = Boolean(options?.hasAuthOverride || hasCodexCredentials());
+    if (!requested && !hasOpenAiKey && !hasXaiKey && !hasFalKey && hasChatGptAuth) {
+        requested = 'chatgpt';
+    }
     // Local ComfyUI backend (offline, GPU) — no API key, workflow-based API.
     if (requested === 'comfyui') {
         const baseUrl = (envSource.COMFYUI_URL
@@ -1515,17 +1833,25 @@ function resolveImageProvider(envSource) {
         }
         return { provider: 'comfyui', model, baseUrl, apiKey: '' };
     }
-    const provider = requested === 'xai' ? 'xai' : 'openai';
+    if (requested === 'chatgpt') {
+        const baseUrl = (envSource.CHATGPT_RESPONSES_URL
+            ?? envSource.CODEBUDDY_IMAGE_BASE_URL
+            ?? CHATGPT_RESPONSES_URL).trim().replace(/\/+$/, '');
+        const model = (envSource.CODEBUDDY_IMAGE_MODEL ?? 'gpt-image-2.5-flare').trim();
+        assertProviderReady('chatgpt', '', baseUrl, 'image', { hasCredentials: hasChatGptAuth });
+        return { provider: 'chatgpt', model, baseUrl, apiKey: '' };
+    }
+    const provider = requested === 'xai' ? 'xai' : (requested === 'fal' ? 'fal' : 'openai');
     const baseUrl = (envSource.CODEBUDDY_IMAGE_BASE_URL
-        ?? (provider === 'xai' ? envSource.XAI_BASE_URL : envSource.OPENAI_BASE_URL)
+        ?? (provider === 'xai' ? envSource.XAI_BASE_URL : (provider === 'fal' ? 'https://queue.fal.run' : envSource.OPENAI_BASE_URL))
         ?? (provider === 'xai' ? 'https://api.x.ai/v1' : 'https://api.openai.com/v1')).trim().replace(/\/+$/, '');
     const apiKey = (envSource.CODEBUDDY_IMAGE_API_KEY
-        ?? (provider === 'xai' ? envSource.XAI_API_KEY : envSource.OPENAI_API_KEY)
+        ?? (provider === 'xai' ? envSource.XAI_API_KEY : (provider === 'fal' ? (envSource.FAL_KEY ?? envSource.FAL_API_KEY) : envSource.OPENAI_API_KEY))
         ?? '').trim();
     const model = (envSource.CODEBUDDY_IMAGE_MODEL
         ?? (provider === 'xai' ? envSource.XAI_IMAGE_MODEL : envSource.OPENAI_IMAGE_MODEL)
         ?? getImageGenerationModel()
-        ?? (provider === 'xai' ? 'grok-imagine-image' : 'gpt-image-2')).trim();
+        ?? (provider === 'xai' ? 'grok-imagine-image' : 'gpt-image-2.5-flare')).trim();
     // Route through the Nous Tool Gateway when configured (transparent base-URL +
     // token substitution); otherwise use the direct provider.
     const route = resolveToolGatewayRoute('image_gen', envSource);
@@ -1783,10 +2109,16 @@ function resolveVideoProvider(modelOverride, envSource) {
     assertProviderReady(provider, effectiveApiKey, effectiveBaseUrl, 'video');
     return { provider, model, baseUrl: effectiveBaseUrl, apiKey: effectiveApiKey };
 }
-function assertProviderReady(provider, apiKey, baseUrl, kind) {
+function assertProviderReady(provider, apiKey, baseUrl, kind, options) {
     if (!baseUrl) {
         throw new Error(`No ${kind} generation base URL configured for provider ${provider}`);
     }
+    if (provider === 'chatgpt') {
+        if (!options?.hasCredentials) {
+            throw new Error('No ChatGPT credentials found for provider chatgpt. Run `buddy login` (or `/login chatgpt`) to connect.');
+        }
+        return;
+    }
     if (!apiKey && !isLocalBaseUrl(baseUrl)) {
         throw new Error(`No ${kind} generation credentials configured for provider ${provider}`);
     }

package/dist/tools/merge-conflict-tool.js

@@ -4,6 +4,7 @@
  * Parses Git merge conflict markers, provides strategy-based resolution
  * (ours, theirs, both, ai), and exposes a tool for the agent to use.
  */
+import { spawnSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { logger } from '../utils/logger.js';
@@ -209,34 +210,61 @@ function indent(text, prefix = '    ') {
 /**
  * Scan the project for files containing merge conflict markers.
  */
+function runGit(args, cwd) {
+    const result = spawnSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 10000,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    });
+    if (result.error) {
+        const code = result.error.code;
+        return { ok: false, reason: code === 'ENOENT' ? 'git is not installed or not on PATH' : result.error.message };
+    }
+    if (result.status !== 0) {
+        return { ok: false, reason: (result.stderr || '').trim() || `git ${args.join(' ')} exited with status ${result.status}` };
+    }
+    return { ok: true, stdout: result.stdout || '' };
+}
 function scanForConflicts(cwd) {
-    try {
-        const { execSync } = require('child_process');
-        const output = execSync('git diff --name-only --diff-filter=U', { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
-        if (!output) {
-            return { success: true, output: 'No files with merge conflicts found.' };
+    // Distinguish "not a repository" and "git unavailable" from "no conflicts":
+    // the former used to be reported for every scan because the ESM module
+    // called an undefined `require` and the catch-all blamed git.
+    const inside = runGit(['rev-parse', '--is-inside-work-tree'], cwd);
+    if (!inside.ok) {
+        return { success: false, error: `Unable to scan for conflicts: ${inside.reason}` };
+    }
+    if (inside.stdout.trim() !== 'true') {
+        return { success: false, error: 'Unable to scan for conflicts: not inside a Git work tree.' };
+    }
+    const diff = runGit(['diff', '--name-only', '--diff-filter=U'], cwd);
+    if (!diff.ok) {
+        return { success: false, error: `Unable to scan for conflicts: ${diff.reason}` };
+    }
+    const output = diff.stdout.trim();
+    if (!output) {
+        return { success: true, output: 'No files with merge conflicts found.' };
+    }
+    // `git diff --name-only` paths are relative to the repository root.
+    const topLevel = runGit(['rev-parse', '--show-toplevel'], cwd);
+    const root = topLevel.ok ? topLevel.stdout.trim() : cwd;
+    const files = output.split('\n').filter(Boolean);
+    const summaries = [];
+    for (const file of files) {
+        const fullPath = path.join(root, file);
+        try {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const conflicts = parseConflicts(content, fullPath);
+            summaries.push(`  ${file}: ${conflicts.length} conflict(s)`);
         }
-        const files = output.split('\n').filter(Boolean);
-        const summaries = [];
-        for (const file of files) {
-            const fullPath = path.join(cwd, file);
-            try {
-                const content = fs.readFileSync(fullPath, 'utf-8');
-                const conflicts = parseConflicts(content, fullPath);
-                summaries.push(`  ${file}: ${conflicts.length} conflict(s)`);
-            }
-            catch {
-                summaries.push(`  ${file}: (unable to read)`);
-            }
+        catch {
+            summaries.push(`  ${file}: (unable to read)`);
         }
-        return {
-            success: true,
-            output: `Files with merge conflicts:\n${summaries.join('\n')}`,
-        };
-    }
-    catch {
-        // Fallback: not in a git repo or git not available
-        return { success: true, output: 'Unable to scan for conflicts (git not available or not in a repository).' };
     }
+    return {
+        success: true,
+        output: `Files with merge conflicts:\n${summaries.join('\n')}`,
+    };
 }
 //# sourceMappingURL=merge-conflict-tool.js.map

package/dist/tools/metadata.d.ts

@@ -1,12 +1,8 @@
-import { ToolMetadata, ToolCategory, ToolEffectClass } from "./types.js";
+import type { ToolMetadata, ToolCategory } from './types.js';
 /**
  * Default tool metadata for all built-in tools
  */
 export declare const TOOL_METADATA: ToolMetadata[];
-/** Resolve a tool's declared effect class. Missing catalog/MCP entries warn once and return `unknown`. */
-export declare function resolveToolEffect(name: string, metadata?: Pick<ToolMetadata, 'effect'> | null): ToolEffectClass | 'unknown';
-/** Test hook: unique-warning latch. */
-export declare function resetToolEffectWarningLatch(): void;
 /** Metadata visible to RAG / BM25. Gated tools stay out of the index when disabled. */
 export declare function getActiveToolMetadata(): ToolMetadata[];
 /**

package/dist/tools/metadata.js

@@ -1,9 +1,12 @@
-import { TOOL_EFFECT_CLASSES } from "./types.js";
-import { logger } from "../utils/logger.js";
 /**
  * Default tool metadata for all built-in tools
  */
 export const TOOL_METADATA = [
+    { name: 'a2a_call', effect: 'emission', category: 'web', keywords: ['a2a', 'peer', 'hermes', 'openclaw', 'delegate'], priority: 6, fleetSafe: false, description: 'Send a task to a configured remote A2A peer; remote execution can have effects and requires permission.' },
+    { name: 'resource_catalog', effect: 'read', category: 'system', keywords: ['resource', 'catalog', 'network', 'fleet', 'ragchat', 'available', 'ressources', 'réseau'], priority: 7, fleetSafe: false, description: 'Read explicit resource declarations and select fresh permitted resources; no probes or dispatch.' },
+    { name: 'ragchat_search', effect: 'read', category: 'web',
+        keywords: ['ragchat', 'pdf', 'corpus', 'citations', 'pages', 'ocr', 'recherche documentaire'],
+        priority: 7, description: 'Search configured authenticated RagChat PDF profiles with exact page citations; read-only.', fleetSafe: false },
     // File reading
     {
         name: 'view_file',
@@ -85,7 +88,7 @@ export const TOOL_METADATA = [
         name: 'self_describe',
         effect: 'read',
         category: 'file_read',
-        keywords: ['self', 'describe', 'components', 'composants', 'briques', 'bricks', 'architecture', 'de quoi es-tu fait', 'de quoi es-tu compose', 'qui es-tu', 'capabilities', 'capacites', 'capteur', 'capteurs', 'sensors', 'modules', 'buddy-sense', 'buddy-vision', 'buddy-memory', 'introspection', 'auto inspection', 'etudie', 'examine', 'inspecte', 'propre code', 'ton code', 'fonctionne', 'fonctionnes', 'fonctionnement', 'limites', 'version', 'conscient', 'consciente', 'conscience', 'consciousness', 'modele de soi'],
+        keywords: ['self', 'describe', 'components', 'composants', 'briques', 'bricks', 'architecture', 'de quoi es-tu fait', 'de quoi es-tu compose', 'qui es-tu', 'capabilities', 'capacites', 'capteur', 'capteurs', 'sensors', 'modules', 'buddy-sense', 'buddy-vision', 'buddy-memory', 'introspection', 'auto inspection', 'etudie', 'examine', 'inspecte', 'propre code', 'ton code', 'fonctionne', 'fonctionnes', 'fonctionnement', 'limites', 'version', 'conscient', 'consciente', 'conscience', 'consciousness', 'modele de soi', 'theme', 'parametres', 'parametrage', 'settings', 'configuration'],
         priority: 50,
         description: "Inspect the robot's attested core, bounded code structure, turn metadata, configured faculties, and epistemic limits without live probes",
         fleetSafe: true,
@@ -215,7 +218,8 @@ export const TOOL_METADATA = [
         category: 'system',
         keywords: ['process', 'spawn', 'kill', 'list', 'logs', 'pid', 'monitor'],
         priority: 6,
-        description: 'Manage system processes (spawn, inspect, logs, terminate)'
+        description: 'Manage system processes (spawn, inspect, logs, terminate)',
+        repeatSafe: true,
     },
     {
         name: 'app_server',
@@ -1151,7 +1155,8 @@ export const TOOL_METADATA = [
         category: 'media',
         keywords: ['gpuNode', 'gpu', 'panoworld', 'longcat', 'avatar', '3dgs', 'world model', 'reconstruction', 'render'],
         priority: 8,
-        description: 'Submit and monitor isolated PanoWorld or LongCat jobs on a configured GPU worker'
+        description: 'Submit and monitor isolated PanoWorld or LongCat jobs on a configured GPU worker',
+        repeatSafe: true,
     },
     {
         name: 'ocr',
@@ -1377,7 +1382,7 @@ export const TOOL_METADATA = [
         category: 'utility',
         keywords: ['skill', 'skills', 'list', 'installed', 'enabled', 'disabled', 'hub', 'hermes'],
         priority: 5,
-        description: 'List installed SKILL.md packages from the local SkillsHub',
+        description: 'List available local skills across bundled, built-in, workspace and hub sources',
         fleetSafe: true,
     },
     {
@@ -1386,7 +1391,7 @@ export const TOOL_METADATA = [
         category: 'utility',
         keywords: ['skill', 'skills', 'view', 'read', 'content', 'inspect', 'show', 'hub', 'hermes'],
         priority: 6,
-        description: 'Read one installed SKILL.md package and its integrity metadata from the local SkillsHub',
+        description: 'Read one local skill and its source or hub integrity metadata',
         fleetSafe: true,
     },
     {
@@ -1714,6 +1719,15 @@ export const TOOL_METADATA = [
         description: 'Generate professional documents (PowerPoint/Word/Excel/PDF) from markdown content'
     },
     // Fleet — multi-Claude orchestration via peer-RPC (Phase (d).17)
+    {
+        name: 'fleet_room',
+        effect: 'emission',
+        fleetSafe: false,
+        category: 'utility',
+        keywords: ['fleet', 'room', 'salon', 'message', 'coordination', 'history', 'robot', 'communication', 'flotte'],
+        priority: 7,
+        description: 'Send messages, read history or check access in the configured Fleet room; messages remain external data, not action authorization',
+    },
     {
         name: 'peer_delegate',
         effect: 'emission',
@@ -2030,27 +2044,6 @@ export const TOOL_METADATA = [
         fleetSafe: true,
     },
 ];
-const missingEffectWarned = new Set();
-function isToolEffectClass(value) {
-    return TOOL_EFFECT_CLASSES.includes(value);
-}
-/** Resolve a tool's declared effect class. Missing catalog/MCP entries warn once and return `unknown`. */
-export function resolveToolEffect(name, metadata) {
-    if (isToolEffectClass(metadata?.effect))
-        return metadata.effect;
-    const catalog = TOOL_METADATA.find((entry) => entry.name === name)?.effect;
-    if (isToolEffectClass(catalog))
-        return catalog;
-    if (!missingEffectWarned.has(name)) {
-        missingEffectWarned.add(name);
-        logger.warn('tool metadata missing effect class; treating as unknown', { tool: name });
-    }
-    return 'unknown';
-}
-/** Test hook: unique-warning latch. */
-export function resetToolEffectWarningLatch() {
-    missingEffectWarned.clear();
-}
 /** Metadata visible to RAG / BM25. Gated tools stay out of the index when disabled. */
 export function getActiveToolMetadata() {
     if (process.env.CODEBUDDY_CONTEXT_ZOOM === 'true')