@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/tools/registry/fleet-tools.js

@@ -1,14 +1,17 @@
 /**
  * Fleet Tool Adapters — Phase (d).17.
  *
- * ITool-compliant wrappers for `peer_delegate` and `list_peers`.
- * Both tools are explicitly NOT fleetSafe — they're outbound from the
- * caller; inbound peers run their own gating via the A2A executor.
+ * ITool-compliant wrappers for `peer_delegate`, `peer_tool_invoke`,
+ * `list_peers`, and `fleet_room`. Fleet tools are explicitly NOT fleetSafe —
+ * they're outbound from the caller; inbound peers run their own gating.
  */
 import { executePeerDelegate } from '../peer-delegate-tool.js';
 import { executePeerChain } from '../peer-chain-tool.js';
 import { executeListPeers } from '../list-peers-tool.js';
+import { executeFleetRoom, fleetRoomInputSchema } from '../fleet-room-tool.js';
+import { FLEET_ROOM_TOOL_DEF } from '../../codebuddy/fleet-tool-defs.js';
 import { executeRoutePeer } from '../route-peer-tool.js';
+import { PEER_TOOL_INVOKE_DESCRIPTION, PEER_TOOL_INVOKE_PARAM_DESCRIPTIONS, executePeerToolInvoke, isFlatToolArgs, } from '../peer-tool-invoke-tool.js';
 import { FLEET_DISPATCH_PROFILES, FLEET_DISPATCH_PROFILE_GUIDANCE_TEXT, isFleetDispatchProfile, } from '../../fleet/dispatch-profile.js';
 const DISPATCH_PROFILE_PARAMETER_DESCRIPTION = 'Optional Fleet dispatch profile. When set, Code Buddy carries the operating posture ' +
     'through peer.chat and returns peer-side policy metadata when supported. Selection guide: ' +
@@ -126,6 +129,110 @@ export class PeerDelegateTool {
         return true;
     }
 }
+export class PeerToolInvokeTool {
+    name = 'peer_tool_invoke';
+    description = PEER_TOOL_INVOKE_DESCRIPTION;
+    async execute(input) {
+        return executePeerToolInvoke({
+            peer: typeof input.peer === 'string' ? input.peer : '',
+            tool: typeof input.tool === 'string' ? input.tool : '',
+            args: input.args,
+            timeoutMs: typeof input.timeoutMs === 'number' ? input.timeoutMs : undefined,
+        });
+    }
+    getSchema() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    peer: {
+                        type: 'string',
+                        minLength: 1,
+                        description: PEER_TOOL_INVOKE_PARAM_DESCRIPTIONS.peer,
+                    },
+                    tool: {
+                        type: 'string',
+                        minLength: 1,
+                        description: PEER_TOOL_INVOKE_PARAM_DESCRIPTIONS.tool,
+                    },
+                    args: {
+                        type: 'object',
+                        description: PEER_TOOL_INVOKE_PARAM_DESCRIPTIONS.args,
+                        properties: {
+                            path: {
+                                type: 'string',
+                                description: 'Peer-relative path, e.g. "oracle.txt" (accepted by view_file and list_directory).',
+                            },
+                            file_path: {
+                                type: 'string',
+                                description: 'Alias of path for view_file.',
+                            },
+                            query: {
+                                type: 'string',
+                                description: 'Search query when tool is search.',
+                            },
+                        },
+                    },
+                    timeoutMs: {
+                        type: 'number',
+                        description: PEER_TOOL_INVOKE_PARAM_DESCRIPTIONS.timeoutMs,
+                    },
+                },
+                required: ['peer', 'tool'],
+            },
+        };
+    }
+    validate(input) {
+        if (typeof input !== 'object' || input === null) {
+            return { valid: false, errors: ['Input must be an object'] };
+        }
+        const inp = input;
+        const errors = [];
+        const keys = Object.keys(inp).join(',') || '(none)';
+        if (typeof inp.peer !== 'string' || !inp.peer) {
+            errors.push(`peer is required (string); received keys: ${keys}`);
+        }
+        if (typeof inp.tool !== 'string' || !inp.tool) {
+            errors.push(`tool is required (string); received keys: ${keys}`);
+        }
+        if (inp.args !== undefined && !isFlatToolArgs(inp.args)) {
+            errors.push('args must be a flat object of string/number/boolean values');
+        }
+        return errors.length === 0 ? { valid: true } : { valid: false, errors };
+    }
+    getMetadata() {
+        return {
+            name: this.name,
+            description: this.description,
+            category: 'utility',
+            keywords: [
+                'peer',
+                'tool',
+                'invoke',
+                'fleet',
+                'view_file',
+                'list_directory',
+                'search',
+                'read',
+                'remote',
+                'workspace',
+                'allowlist',
+                'file',
+                'oracle',
+            ],
+            priority: 8,
+            modifiesFiles: false,
+            makesNetworkRequests: true,
+            effect: 'emission',
+            fleetSafe: false,
+        };
+    }
+    isAvailable() {
+        return true;
+    }
+}
 export class ListPeersTool {
     name = 'list_peers';
     description = 'List all connected fleet peers with their status (last seen, compacting, peer chat availability). ' +
@@ -478,8 +585,34 @@ export class PeerChainTool {
         return true;
     }
 }
+export class FleetRoomTool {
+    name = 'fleet_room';
+    description = FLEET_ROOM_TOOL_DEF.function.description;
+    async execute(input) {
+        return executeFleetRoom(input);
+    }
+    getSchema() {
+        return { name: this.name, description: this.description, parameters: FLEET_ROOM_TOOL_DEF.function.parameters };
+    }
+    validate(input) {
+        return fleetRoomInputSchema.safeParse(input).success
+            ? { valid: true }
+            : { valid: false, errors: ['Invalid fleet_room action or arguments; destination and identity cannot be overridden.'] };
+    }
+    getMetadata() {
+        return { name: this.name, description: this.description, category: 'utility', keywords: ['fleet', 'room', 'salon', 'message', 'coordination', 'history', 'robot'], priority: 7, modifiesFiles: false, makesNetworkRequests: true, effect: 'emission', fleetSafe: false, requiresConfirmation: true };
+    }
+    isAvailable() { return true; }
+}
 export function createFleetTools() {
-    return [new PeerDelegateTool(), new PeerChainTool(), new ListPeersTool(), new RoutePeerTool()];
+    return [
+        new PeerDelegateTool(),
+        new PeerToolInvokeTool(),
+        new PeerChainTool(),
+        new ListPeersTool(),
+        new RoutePeerTool(),
+        new FleetRoomTool(),
+    ];
 }
 export function resetFleetToolInstances() {
     // Stateless adapter classes — nothing to reset.

package/dist/tools/registry/index.d.ts

@@ -76,7 +76,7 @@ export { VerifyTool, createVerifyTools, resetVerifyInstances, setVerifyToolProvi
 export type { VerifyToolProvider, VerifyLlmCall, VerifyExecuteTool, } from './verify-tools.js';
 export { DelegateAgentTool, createDelegateAgentTools, resetDelegateAgentInstances, setDelegateAgentProvider, resetDelegateAgentProvider, } from './delegate-agent-tools.js';
 export type { DelegateAgentProvider, DelegateLlmCall, DelegateExecuteTool, } from './delegate-agent-tools.js';
-export { PeerDelegateTool, PeerChainTool, ListPeersTool, RoutePeerTool, createFleetTools, resetFleetToolInstances, } from './fleet-tools.js';
+export { PeerDelegateTool, PeerToolInvokeTool, PeerChainTool, ListPeersTool, RoutePeerTool, createFleetTools, resetFleetToolInstances, } from './fleet-tools.js';
 export { CodeExplorerAskTool, createCodeExplorerTools, resetCodeExplorerInstances, } from './code-explorer-tools.js';
 export { ScreenMemoryTool, createScreenpipeTools, resetScreenpipeInstances, } from './screenpipe-tools.js';
 export { AskUserQuestionExecuteTool, createAskUserQuestionTools, resetAskUserQuestionInstances, } from './ask-user-question-tools.js';

package/dist/tools/registry/index.js

@@ -129,8 +129,8 @@ export { AdvisorExecuteTool, createAdvisorTools, resetAdvisorInstances, setAdvis
 export { VerifyTool, createVerifyTools, resetVerifyInstances, setVerifyToolProvider, resetVerifyToolProvider, } from './verify-tools.js';
 // Tool Adapters - Delegate Agent (reaches the built-in specialized agents)
 export { DelegateAgentTool, createDelegateAgentTools, resetDelegateAgentInstances, setDelegateAgentProvider, resetDelegateAgentProvider, } from './delegate-agent-tools.js';
-// Tool Adapters - Fleet (peer_delegate, list_peers, route_peer)
-export { PeerDelegateTool, PeerChainTool, ListPeersTool, RoutePeerTool, createFleetTools, resetFleetToolInstances, } from './fleet-tools.js';
+// Tool Adapters - Fleet (peer_delegate, peer_tool_invoke, list_peers, route_peer)
+export { PeerDelegateTool, PeerToolInvokeTool, PeerChainTool, ListPeersTool, RoutePeerTool, createFleetTools, resetFleetToolInstances, } from './fleet-tools.js';
 // Tool Adapters - CodeExplorer
 export { CodeExplorerAskTool, createCodeExplorerTools, resetCodeExplorerInstances, } from './code-explorer-tools.js';
 // Tool Adapters - Screenpipe (screen_memory)

package/dist/tools/registry/knowledge-tools.d.ts

@@ -6,7 +6,7 @@
  *  - knowledge_add: create a new knowledge entry from within a session
  */
 import type { ToolResult } from '../../types/index.js';
-import type { ITool, ToolSchema, IToolMetadata, IValidationResult } from './types.js';
+import type { ITool, IToolExecutionContext, ToolSchema, IToolMetadata, IValidationResult } from './types.js';
 export declare class KnowledgeSearchTool implements ITool {
     readonly name = "knowledge_search";
     readonly description = "Search the agent knowledge base for domain knowledge, conventions, or procedures. Returns ranked excerpts from loaded Knowledge.md files.";
@@ -37,7 +37,7 @@ export declare class AskHumanExecuteTool implements ITool {
 export declare class CreateSkillExecuteTool implements ITool {
     readonly name = "create_skill";
     readonly description = "Create a new SKILL.md file in the workspace skills directory. Use this to codify reusable workflows or procedures for future sessions. Skills are hot-reloaded immediately.";
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
     getSchema(): ToolSchema;
     validate(input: unknown): IValidationResult;
     getMetadata(): IToolMetadata;

package/dist/tools/registry/knowledge-tools.js

@@ -233,7 +233,7 @@ import { getCreateSkillTool } from '../create-skill-tool.js';
 export class CreateSkillExecuteTool {
     name = 'create_skill';
     description = 'Create a new SKILL.md file in the workspace skills directory. Use this to codify reusable workflows or procedures for future sessions. Skills are hot-reloaded immediately.';
-    async execute(input) {
+    async execute(input, context) {
         return await getCreateSkillTool().execute({
             name: input.name,
             description: input.description,
@@ -242,7 +242,7 @@ export class CreateSkillExecuteTool {
             env: input.env,
             requires: input.requires,
             overwrite: input.overwrite,
-        });
+        }, context?.cwd);
     }
     getSchema() {
         return getCreateSkillTool().getSchema();

package/dist/tools/registry/lessons-tools.d.ts

@@ -55,6 +55,13 @@ export declare class LessonsGraphTool implements ITool {
     getMetadata(): IToolMetadata;
     isAvailable(): boolean;
 }
+/**
+ * Resolve a project-local binary (`node_modules/.bin/<name>`, walking up from
+ * `cwd`). `npx <name>` is deliberately avoided: when the tool is not installed
+ * it silently fetches a package from the npm registry (for `tsc`, an unrelated
+ * package), which is slow, offline-hostile and not the project's compiler.
+ */
+export declare function resolveProjectBin(name: string, cwd: string): string | null;
 export declare class TaskVerifyTool implements ITool {
     readonly name = "task_verify";
     readonly description: string;

package/dist/tools/registry/lessons-tools.js

@@ -9,6 +9,8 @@
  * - TaskVerifyTool    (`task_verify`)    — run tsc/tests/lint verification contract
  */
 import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
 import { getLessonsTracker, renderLessonConceptGraph, } from '../../agent/lessons-tracker.js';
 // ============================================================================
 // LessonsAddTool
@@ -480,11 +482,49 @@ function runCheck(cmd, args, cwd, timeoutMs = 60_000) {
     const pass = result.status === 0 && !result.error;
     return { pass, output };
 }
+/**
+ * Resolve a project-local binary (`node_modules/.bin/<name>`, walking up from
+ * `cwd`). `npx <name>` is deliberately avoided: when the tool is not installed
+ * it silently fetches a package from the npm registry (for `tsc`, an unrelated
+ * package), which is slow, offline-hostile and not the project's compiler.
+ */
+export function resolveProjectBin(name, cwd) {
+    const candidates = process.platform === 'win32' ? [`${name}.cmd`, name] : [name];
+    let dir = path.resolve(cwd);
+    for (;;) {
+        for (const candidate of candidates) {
+            const full = path.join(dir, 'node_modules', '.bin', candidate);
+            if (fs.existsSync(full))
+                return full;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function runProjectBin(name, args, cwd, packageHint, timeoutMs = 60_000) {
+    const bin = resolveProjectBin(name, cwd);
+    if (!bin) {
+        return {
+            pass: false,
+            output: `${name} not found in node_modules/.bin of ${cwd} or its parents; install ${packageHint} in the project (nothing was downloaded).`,
+        };
+    }
+    if (bin.endsWith('.cmd')) {
+        // Windows shims need a shell; args are fixed internal flags, only the path needs quoting.
+        const quoted = [`"${bin}"`, ...args].join(' ');
+        const result = spawnSync(quoted, { cwd, encoding: 'utf-8', timeout: timeoutMs, shell: true });
+        const raw = [result.stdout ?? '', result.stderr ?? ''].join('\n').trim();
+        return { pass: result.status === 0 && !result.error, output: raw.length > 2000 ? '...(truncated)\n' + raw.slice(-2000) : raw };
+    }
+    return runCheck(bin, args, cwd, timeoutMs);
+}
 export class TaskVerifyTool {
     name = 'task_verify';
     description = [
         'Run verification checks before marking a task complete (Verification Contract).',
-        'Checks: typescript (npx tsc --noEmit), tests (auto-detected from package.json), lint (eslint).',
+        'Checks: typescript (project-local tsc --noEmit), tests (auto-detected from package.json), lint (project-local eslint).',
         'Returns pass/fail per check with truncated output.',
         'Call this before every task completion to satisfy the Verification Contract.',
     ].join(' ');
@@ -501,7 +541,7 @@ export class TaskVerifyTool {
         for (const check of checks) {
             let res;
             if (check === 'typescript') {
-                res = runCheck('npx', ['tsc', '--noEmit'], workDir);
+                res = runProjectBin('tsc', ['--noEmit'], workDir, 'typescript');
             }
             else if (check === 'tests') {
                 // Try to detect test command from RepoProfiler cache
@@ -526,7 +566,7 @@ export class TaskVerifyTool {
             }
             else {
                 // lint
-                res = runCheck('npx', ['eslint', '.', '--max-warnings=0'], workDir, 60_000);
+                res = runProjectBin('eslint', ['.', '--max-warnings=0'], workDir, 'eslint', 60_000);
             }
             results.push({ check, pass: res.pass, output: res.output });
         }

package/dist/tools/registry/memory-tools.d.ts

@@ -31,7 +31,7 @@ export declare class ReplaceMemoryTool implements ITool {
 export declare class MemoryProposeTool implements ITool {
     readonly name = "memory_propose";
     readonly description = "Propose a long-term memory candidate for human review. Use this instead of remember when the fact is inferred, ambiguous, or should not be silently injected into future prompts.";
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
     getSchema(): ToolSchema;
     validate(input: unknown): IValidationResult;
     getMetadata(): IToolMetadata;

package/dist/tools/registry/memory-tools.js

@@ -21,14 +21,14 @@ export class RememberTool {
         // Per-bot memory (multi-bot channels): scope by botId so bots don't share
         // each other's facts. No botId = global memory (default). initialize() is
         // idempotent, so this is cheap for the already-initialized global instance.
-        const mm = getMemoryManager(undefined, context?.botId);
+        const mm = getMemoryManager(undefined, context?.botId, context?.cwd);
         await mm.initialize();
         let key = input.key;
         let value = input.value;
         let scope = input.scope ?? 'project';
         let category = input.category ?? 'custom';
         try {
-            const hookResult = await executeHermesLifecycleHook(process.cwd(), 'before_memory_write', {
+            const hookResult = await executeHermesLifecycleHook(context?.cwd ?? process.cwd(), 'before_memory_write', {
                 toolName: this.name,
                 toolInput: { key, value, scope, category },
                 memoryKey: key,
@@ -134,14 +134,14 @@ export class ReplaceMemoryTool {
         // Per-bot memory (multi-bot channels): scope by botId so bots don't share
         // each other's facts. No botId = global memory (default). initialize() is
         // idempotent, so this is cheap for the already-initialized global instance.
-        const mm = getMemoryManager(undefined, context?.botId);
+        const mm = getMemoryManager(undefined, context?.botId, context?.cwd);
         await mm.initialize();
         let key = input.key;
         let value = input.value;
         let scope = input.scope ?? 'project';
         let category = input.category;
         try {
-            const hookResult = await executeHermesLifecycleHook(process.cwd(), 'before_memory_write', {
+            const hookResult = await executeHermesLifecycleHook(context?.cwd ?? process.cwd(), 'before_memory_write', {
                 toolName: this.name,
                 toolInput: { key, value, scope, category },
                 memoryKey: key,
@@ -249,7 +249,7 @@ export class ReplaceMemoryTool {
 export class MemoryProposeTool {
     name = 'memory_propose';
     description = 'Propose a long-term memory candidate for human review. Use this instead of remember when the fact is inferred, ambiguous, or should not be silently injected into future prompts.';
-    async execute(input) {
+    async execute(input, context) {
         const key = input.key;
         const value = input.value;
         const scope = input.scope ?? 'project';
@@ -257,7 +257,7 @@ export class MemoryProposeTool {
         const confidence = typeof input.confidence === 'number' ? input.confidence : undefined;
         const rationale = typeof input.rationale === 'string' ? input.rationale : undefined;
         try {
-            const { candidate, deduped } = getMemoryCandidateQueue(process.cwd()).propose({
+            const { candidate, deduped } = getMemoryCandidateQueue(context?.cwd ?? process.cwd(), context?.botId).propose({
                 key,
                 value,
                 scope,
@@ -355,7 +355,7 @@ export class RecallTool {
         // Per-bot memory (multi-bot channels): scope by botId so bots don't share
         // each other's facts. No botId = global memory (default). initialize() is
         // idempotent, so this is cheap for the already-initialized global instance.
-        const mm = getMemoryManager(undefined, context?.botId);
+        const mm = getMemoryManager(undefined, context?.botId, context?.cwd);
         try {
             await mm.initialize();
             const key = input.key;
@@ -438,7 +438,7 @@ export class ForgetTool {
         // Per-bot memory (multi-bot channels): scope by botId so bots don't share
         // each other's facts. No botId = global memory (default). initialize() is
         // idempotent, so this is cheap for the already-initialized global instance.
-        const mm = getMemoryManager(undefined, context?.botId);
+        const mm = getMemoryManager(undefined, context?.botId, context?.cwd);
         try {
             await mm.initialize();
             const key = input.key;

package/dist/tools/registry/research-tools.d.ts

@@ -5,6 +5,7 @@
  * DISPATCHABLE in interactive chat (via `ToolHandler.initializeRegistry`), not
  * only in headless/multi-agent runs:
  *  - `deep_research` — src/tools/deep-research-tool.ts (multi-source web research).
+ *  - `ragchat_search` — authenticated read-only RagChat PDF passages.
  *  - `paper_qa` — src/tools/paper-qa-tool.ts (grounded, cited QA over a PDF corpus).
  *
  * The adapters themselves (business delegation + conservative in-chat bounds)

package/dist/tools/registry/research-tools.js

@@ -1,21 +1,12 @@
-/**
- * Research Tool Adapters (factory)
- *
- * Wires the research ITool adapters into the FormalToolRegistry so they are
- * DISPATCHABLE in interactive chat (via `ToolHandler.initializeRegistry`), not
- * only in headless/multi-agent runs:
- *  - `deep_research` — src/tools/deep-research-tool.ts (multi-source web research).
- *  - `paper_qa` — src/tools/paper-qa-tool.ts (grounded, cited QA over a PDF corpus).
- *
- * The adapters themselves (business delegation + conservative in-chat bounds)
- * live in those files; this factory only instantiates them.
- */
+import { A2ACallTool } from '../a2a-call-tool.js';
 import { DeepResearchTool } from '../deep-research-tool.js';
+import { ResourceCatalogTool } from '../resource-catalog-tool.js';
+import { RagChatTool } from '../ragchat-tool.js';
 import { PaperQaTool } from '../paper-qa-tool.js';
 /**
  * Create all research tool instances.
  */
 export function createResearchTools() {
-    return [new DeepResearchTool(), new PaperQaTool()];
+    return [new DeepResearchTool(), new PaperQaTool(), new RagChatTool(), new ResourceCatalogTool(), new A2ACallTool()];
 }
 //# sourceMappingURL=research-tools.js.map

package/dist/tools/registry/self-describe-tools.d.ts

@@ -12,7 +12,7 @@ import type { ToolResult } from '../../types/index.js';
 import type { ITool, ToolSchema, IToolMetadata, IValidationResult, IToolExecutionContext } from './types.js';
 export declare class SelfDescribeTool implements ITool {
     readonly name = "self_describe";
-    readonly description = "Inspect what THIS robot/agent is made of and what is evidenced on the current turn: constituent bricks, source/build revision, relevant curated code areas, model/provider/surface, registered versus exposed tools, configuration-only faculties, and limits. Hardware/service availability is omitted unless the host supplied an attestation; this tool performs no live probes. Use it for technical introspection, capabilities, version, and 'de quoi es-tu compos\u00E9'. It reports a verifiable operational self-model, never subjective consciousness. Read-only, auto-approved.";
+    readonly description: string;
     execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
     getSchema(): ToolSchema;
     validate(input: unknown): IValidationResult;

package/dist/tools/registry/self-describe-tools.js

@@ -1,13 +1,4 @@
-/**
- * Self-describe tool adapter.
- *
- * ITool exposing `self_describe` — "de quoi es-tu fait ?": the robot's live
- * manifest of the bricks that compose it (buddy-sense, buddy-vision,
- * buddy-memory) plus its registered/configured faculties (tools, providers,
- * sensors), without inferring runtime liveness. Read-only,
- * auto-approved. The result text flows back through the normal agent→voice path
- * so the companion can speak it. See src/tools/self-describe.ts.
- */
+import { SELF_DESCRIBE_TOOL } from '../../codebuddy/tool-definitions/self-describe-tools.js';
 import { buildSelfDescription } from '../self-describe.js';
 import { buildOperationalSelfModel, resolveCodeBuddyCoreRoot, } from '../../identity/operational-self-model.js';
 function stringList(value) {
@@ -32,7 +23,7 @@ function contextString(context, key) {
 }
 export class SelfDescribeTool {
     name = 'self_describe';
-    description = "Inspect what THIS robot/agent is made of and what is evidenced on the current turn: constituent bricks, source/build revision, relevant curated code areas, model/provider/surface, registered versus exposed tools, configuration-only faculties, and limits. Hardware/service availability is omitted unless the host supplied an attestation; this tool performs no live probes. Use it for technical introspection, capabilities, version, and 'de quoi es-tu composé'. It reports a verifiable operational self-model, never subjective consciousness. Read-only, auto-approved.";
+    description = SELF_DESCRIBE_TOOL.function.description;
     async execute(input, context) {
         // Resolve registered/configured faculties best-effort — a failure just omits that detail.
         let toolNames;
@@ -49,7 +40,14 @@ export class SelfDescribeTool {
         // environment); otherwise identity remains omitted.
         const personaRobotName = contextString(context, 'robotName') ?? process.env.CODEBUDDY_ROBOT_NAME?.trim();
         const exposedToolNames = stringList(context?.extra?.exposedToolNames);
+        const { getRuntimeSettingsSnapshot } = await import('../../services/runtime-settings-context.js');
+        const settings = getRuntimeSettingsSnapshot({
+            surface: contextString(context, 'surface'), model: contextString(context, 'model'),
+            provider: contextString(context, 'provider'),
+            maxToolRounds: typeof context?.extra?.maxToolRounds === 'number' ? context.extra.maxToolRounds : undefined,
+        });
         const runtime = {
+            ...(settings.theme ? { theme: settings.theme.active } : {}),
             ...(contextString(context, 'model') ? { model: contextString(context, 'model') } : {}),
             ...(contextString(context, 'provider') ? { provider: contextString(context, 'provider') } : {}),
             ...(contextString(context, 'surface') ? { surface: contextString(context, 'surface') } : {}),
@@ -68,6 +66,22 @@ export class SelfDescribeTool {
             exposedToolNames,
             personaRobotName,
         });
+        if (input.operation) {
+            try {
+                const { inspectCoreCode } = await import('../core-code-inspection.js');
+                const inspection = inspectCoreCode(core, {
+                    operation: input.operation,
+                    path: typeof input.path === 'string' ? input.path : undefined,
+                    query: typeof input.query === 'string' ? input.query : undefined,
+                    line: typeof input.line === 'number' ? input.line : undefined,
+                    offset: typeof input.offset === 'number' ? input.offset : undefined,
+                });
+                return { success: true, output: JSON.stringify({ settings, inspection }), data: { settings, inspection } };
+            }
+            catch (error) {
+                return { success: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
         const operational = buildOperationalSelfModel({
             coreResolution: core,
             focus,
@@ -77,8 +91,9 @@ export class SelfDescribeTool {
         });
         return {
             success: true,
-            output: `${description.text}\n\n${operational.text}`,
+            output: `${description.text}\n\n${operational.text}\n\nCurrent runtime settings: ${JSON.stringify(settings)}`,
             data: {
+                settings,
                 description: description,
                 operational: operational,
             },
@@ -88,23 +103,7 @@ export class SelfDescribeTool {
         return {
             name: this.name,
             description: this.description,
-            parameters: {
-                type: 'object',
-                properties: {
-                    focus: {
-                        type: 'string',
-                        maxLength: 320,
-                        description: 'Aspect of this agent to inspect (voice, memory, routing, architecture, limitation).',
-                    },
-                    depth: {
-                        type: 'string',
-                        enum: ['summary', 'deep'],
-                        description: 'Depth of the curated code inspection.',
-                    },
-                },
-                required: [],
-                additionalProperties: false,
-            },
+            parameters: SELF_DESCRIBE_TOOL.function.parameters,
         };
     }
     validate(input) {
@@ -118,7 +117,21 @@ export class SelfDescribeTool {
         if (value.depth !== undefined && value.depth !== 'summary' && value.depth !== 'deep') {
             return { valid: false, errors: ['depth must be summary or deep'] };
         }
-        const unknown = Object.keys(value).filter((key) => key !== 'focus' && key !== 'depth');
+        if (value.operation !== undefined && !['list', 'read', 'search'].includes(String(value.operation))) {
+            return { valid: false, errors: ['operation must be list, read or search'] };
+        }
+        for (const key of ['path', 'query']) {
+            if (value[key] !== undefined && (typeof value[key] !== 'string' || value[key].length > 160)) {
+                return { valid: false, errors: [`${key} must be a string of at most 160 characters`] };
+            }
+        }
+        if (value.line !== undefined && (!Number.isSafeInteger(value.line) || Number(value.line) < 1)) {
+            return { valid: false, errors: ['line must be a positive integer'] };
+        }
+        if (value.offset !== undefined && (!Number.isSafeInteger(value.offset) || Number(value.offset) < 0)) {
+            return { valid: false, errors: ['offset must be a non-negative integer'] };
+        }
+        const unknown = Object.keys(value).filter((key) => !['focus', 'depth', 'operation', 'path', 'query', 'line', 'offset'].includes(key));
         if (unknown.length > 0) {
             return { valid: false, errors: [`unknown input field(s): ${unknown.join(', ')}`] };
         }

package/dist/tools/resource-catalog-tool.d.ts

@@ -0,0 +1,38 @@
+import { ResourceCatalog } from '../fleet/resource-catalog.js';
+import type { ToolResult } from '../types/index.js';
+import type { ITool, IToolMetadata, IValidationResult } from './registry/types.js';
+export declare class ResourceCatalogTool implements ITool {
+    private readonly catalog;
+    readonly name = "resource_catalog";
+    readonly description: string;
+    constructor(catalog?: ResourceCatalog);
+    getSchema(): {
+        name: string;
+        description: string;
+        parameters: {
+            type: "object";
+            properties: {
+                operation: {
+                    type: "string";
+                    enum: string[];
+                    description: string;
+                };
+                capability: {
+                    type: "string";
+                    description: string;
+                };
+                kind: {
+                    type: "string";
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: false;
+        };
+    };
+    getMetadata(): IToolMetadata;
+    isAvailable(): boolean;
+    validate(input: unknown): IValidationResult;
+    execute(input: Record<string, unknown>): Promise<ToolResult>;
+}

package/dist/tools/resource-catalog-tool.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { publicResourceStatus, ResourceCatalog, resourceSchema, selectionWarning } from '../fleet/resource-catalog.js';
+import { RESOURCE_CATALOG_TOOL_DEF } from '../codebuddy/resource-catalog-tool-defs.js';
+const schema = z.discriminatedUnion('operation', [
+    z.object({ operation: z.literal('list') }).strict(),
+    z.object({ operation: z.literal('select'), capability: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,95}$/),
+        kind: resourceSchema.shape.kind.optional() }).strict(),
+]);
+export class ResourceCatalogTool {
+    catalog;
+    name = 'resource_catalog';
+    description = RESOURCE_CATALOG_TOOL_DEF.function.description;
+    constructor(catalog = new ResourceCatalog()) {
+        this.catalog = catalog;
+    }
+    getSchema() { return RESOURCE_CATALOG_TOOL_DEF.function; }
+    getMetadata() {
+        return { name: this.name, description: this.description, category: 'system',
+            keywords: ['resource', 'catalog', 'network', 'fleet', 'ragchat', 'available', 'ressources', 'réseau'],
+            priority: 7, modifiesFiles: false, makesNetworkRequests: false };
+    }
+    isAvailable() { return true; }
+    validate(input) {
+        return schema.safeParse(input).success ? { valid: true } : { valid: false, errors: ['Paramètres du catalogue invalides.'] };
+    }
+    async execute(input) {
+        const parsed = schema.safeParse(input);
+        if (!parsed.success)
+            return { success: false, error: 'Paramètres du catalogue invalides ; seules list et select sont disponibles.' };
+        try {
+            const args = parsed.data;
+            const result = args.operation === 'list' ? { resources: (await this.catalog.list()).map(publicResourceStatus) }
+                : await this.catalog.select(args.capability, args.kind).then(choice => {
+                    const warning = selectionWarning(choice.selected);
+                    return { excluded: choice.excluded, reason: choice.reason,
+                        selected: choice.selected ? publicResourceStatus(choice.selected) : null, ...(warning ? { warning } : {}) };
+                });
+            return { success: true, output: JSON.stringify({ ...result, dispatched: false, probed: false,
+                    instruction: 'Déclarations explicites, santé observée sans preuve d’usage et charge inconnue. Aucune sonde ni exécution effectuée. Une sélection ne change pas les endpoints des autres outils ; ragchat_search utilise RAGCHAT_BASE_URL configuré séparément.' }) };
+        }
+        catch {
+            return { success: false, error: 'Catalogue indisponible ou invalide ; aucune sonde, écriture ni exécution effectuée.' };
+        }
+    }
+}
+//# sourceMappingURL=resource-catalog-tool.js.map