@phuetz/code-buddy 2.1.0 → 2.2.0

package/dist/tools/peer-tool-invoke-tool.js

@@ -0,0 +1,396 @@
+/**
+ * peer_tool_invoke tool — wraps `peer.tool.invoke` for the local agent.
+ *
+ * Lets the LLM read/search on a connected fleet peer (view_file,
+ * list_directory, search) without going through `peer.chat` (which has
+ * no tools). The three security gates stay on the remote peer
+ * (`peer-tool-bridge.ts`): allowlist, fleetSafe, workspace root.
+ *
+ * Extra tool names from `peer.describe` are trusted only when
+ * `CODEBUDDY_PEER_TRUST_DESCRIBE=true`. B still enforces its own
+ * allowlist even then.
+ *
+ * This side (A) does not interpret paths and does not add new remote
+ * capabilities. Failures always return `success: false`.
+ *
+ * @module src/tools/peer-tool-invoke-tool
+ */
+import { getFleetRegistry } from '../fleet/fleet-registry.js';
+import { redactSecrets } from '../fleet/privacy-lint.js';
+import { logger } from '../utils/logger.js';
+export const DEFAULT_PEER_TOOL_INVOKE_TOOLS = [
+    'view_file',
+    'list_directory',
+    'search',
+];
+export const DEFAULT_TIMEOUT_MS = 15_000;
+export const MIN_TIMEOUT_MS = 1_000;
+export const MAX_TIMEOUT_MS = 120_000;
+export const MAX_ARGS_BYTES = 64 * 1024;
+export const MAX_OUTPUT_BYTES = 256 * 1024;
+export const MAX_PEER_ID_LENGTH = 128;
+export const MAX_TOOL_NAME_LENGTH = 64;
+/** Imperative tool description with a concrete call example for local models. */
+export const PEER_TOOL_INVOKE_DESCRIPTION = 'Read or search a file on a connected fleet peer (read-only, allowlist on that peer). ' +
+    'Always pass peer and tool; never call with empty arguments. ' +
+    'Example: {"peer":"B","tool":"view_file","args":{"path":"oracle.txt"}}. ' +
+    'Allowed tools: view_file, list_directory, search. Do not use local view_file for files that live on another peer.';
+export const PEER_TOOL_INVOKE_PARAM_DESCRIPTIONS = {
+    peer: 'Required. Connected peer id from list_peers (the --name of /fleet listen). Example: "B".',
+    tool: 'Required. Read-only tool on that peer. Default set: view_file, list_directory, search. Extra names from peer.describe are accepted only when CODEBUDDY_PEER_TRUST_DESCRIBE=true. Example: "view_file".',
+    args: 'Object of arguments for the remote tool. For view_file use {"path":"oracle.txt"} or {"file_path":"oracle.txt"}. For list_directory use {"path":"."}. For search use {"query":"TODO","path":"src"}. Paths are relative to the peer workspace and are not resolved on this host.',
+    timeoutMs: `Optional timeout in milliseconds. Default ${DEFAULT_TIMEOUT_MS}. Min ${MIN_TIMEOUT_MS}. Max ${MAX_TIMEOUT_MS}.`,
+};
+const DESCRIBE_TIMEOUT_MS = 3_000;
+export const PEER_ID_RE = /^[a-zA-Z0-9._-]{1,128}$/;
+const TOOL_NAME_RE = /^[a-z][a-z0-9_]{0,63}$/;
+const ARG_KEY_RE = /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/;
+const DENIED_TOOL_PREFIXES = ['peer_', 'fleet_', 'agent_', 'delegate_'];
+const DENIED_ARG_KEYS = new Set(['constructor', 'prototype', '__proto__']);
+export function clampPeerToolInvokeTimeout(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0) {
+        return DEFAULT_TIMEOUT_MS;
+    }
+    const n = Math.floor(raw);
+    if (n < MIN_TIMEOUT_MS)
+        return MIN_TIMEOUT_MS;
+    return Math.min(n, MAX_TIMEOUT_MS);
+}
+function isDeniedToolName(name) {
+    return DENIED_TOOL_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function trustDescribeExtras() {
+    return process.env.CODEBUDDY_PEER_TRUST_DESCRIBE === 'true';
+}
+export function isFlatToolArgs(value) {
+    if (value === undefined)
+        return true;
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+        if (DENIED_ARG_KEYS.has(key) || !ARG_KEY_RE.test(key))
+            return false;
+        const item = record[key];
+        if (item === null || item === undefined)
+            continue;
+        const t = typeof item;
+        if (t !== 'string' && t !== 'number' && t !== 'boolean')
+            return false;
+    }
+    return true;
+}
+function argsByteLength(args) {
+    try {
+        return Buffer.byteLength(JSON.stringify(args), 'utf8');
+    }
+    catch {
+        return MAX_ARGS_BYTES + 1;
+    }
+}
+const POSIX_ABS_PATH = /(^|[^A-Za-z0-9._~-])((?:\/[A-Za-z0-9._-]+)+)/g;
+const WIN_ABS_PATH = /[A-Za-z]:\\[^\s"'`,;)\]]+/g;
+const FILE_URL_PATH = /file:\/\/\/?[^\s"'`,;)\]]+/g;
+const HOME_TILDE_PATH = /(^|[^A-Za-z0-9._-])(~\/[^\s"'`,;)\]]*)/g;
+/**
+ * Strip absolute paths and secrets from a peer error before it reaches the
+ * model. Known refusal codes are mapped to path-free sentences; this covers
+ * the unrecognized fallback (and peer.describe failures).
+ */
+export function redactPeerToolInvokeError(text) {
+    let out = text;
+    out = out.replace(WIN_ABS_PATH, '[redacted-path]');
+    out = out.replace(FILE_URL_PATH, '[redacted-path]');
+    out = out.replace(POSIX_ABS_PATH, (_full, prefix) => `${prefix}[redacted-path]`);
+    out = out.replace(HOME_TILDE_PATH, (_full, prefix) => `${prefix}[redacted-path]`);
+    out = redactSecrets(out);
+    return out.replace(/\s+/g, ' ').trim();
+}
+function truncateOutput(text) {
+    if (Buffer.byteLength(text, 'utf8') <= MAX_OUTPUT_BYTES) {
+        return { output: text, truncated: false };
+    }
+    let end = text.length;
+    let slice = text;
+    while (end > 0 && Buffer.byteLength(slice, 'utf8') > MAX_OUTPUT_BYTES) {
+        end = Math.max(0, end - Math.ceil((Buffer.byteLength(slice, 'utf8') - MAX_OUTPUT_BYTES) / 2) - 1);
+        slice = text.slice(0, end);
+    }
+    return { output: `${slice}\n…[truncated by peer_tool_invoke at ${MAX_OUTPUT_BYTES} bytes]`, truncated: true };
+}
+function extractAdvertisedPeerTools(describe) {
+    const names = new Set();
+    const add = (value) => {
+        if (typeof value === 'string') {
+            const name = value.trim();
+            if (TOOL_NAME_RE.test(name) && !isDeniedToolName(name)) {
+                names.add(name);
+            }
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value)
+                add(item);
+        }
+    };
+    if (!describe || typeof describe !== 'object')
+        return [];
+    const payload = describe;
+    add(payload.peerTools);
+    add(payload.tools);
+    add(payload.peerToolAllowlist);
+    if (payload.capabilities && typeof payload.capabilities === 'object') {
+        const caps = payload.capabilities;
+        add(caps.peerTools);
+        add(caps.tools);
+    }
+    return [...names];
+}
+async function isToolAllowedOnPeer(toolName, request) {
+    if (DEFAULT_PEER_TOOL_INVOKE_TOOLS.includes(toolName)) {
+        return { allowed: true, advertised: [...DEFAULT_PEER_TOOL_INVOKE_TOOLS] };
+    }
+    if (isDeniedToolName(toolName)) {
+        return { allowed: false, advertised: [...DEFAULT_PEER_TOOL_INVOKE_TOOLS] };
+    }
+    if (!trustDescribeExtras()) {
+        return { allowed: false, advertised: [...DEFAULT_PEER_TOOL_INVOKE_TOOLS] };
+    }
+    try {
+        const described = await request('peer.describe', {}, { timeoutMs: DESCRIBE_TIMEOUT_MS });
+        const advertised = extractAdvertisedPeerTools(described);
+        return { allowed: advertised.includes(toolName), advertised };
+    }
+    catch (err) {
+        return {
+            allowed: false,
+            advertised: [...DEFAULT_PEER_TOOL_INVOKE_TOOLS],
+            describeError: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function mapRemoteError(peer, err, timeoutMs) {
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err.code ?? '';
+    const combined = `${code} ${message}`;
+    if (code === 'ROLE_LEAF' || combined.includes('ROLE_LEAF')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: it is configured as a leaf peer and cannot accept outbound peer.tool.invoke from this caller.`,
+        };
+    }
+    if (code === 'MAX_DEPTH_EXCEEDED' || combined.includes('MAX_DEPTH_EXCEEDED')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: call chain depth exceeded (MAX_DEPTH_EXCEEDED).`,
+        };
+    }
+    if (code === 'REQUEST_TIMEOUT' || combined.includes('REQUEST_TIMEOUT')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" did not respond to peer.tool.invoke within ${timeoutMs}ms.`,
+        };
+    }
+    if (code === 'DISCONNECTED' || combined.includes('DISCONNECTED')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" disconnected during peer.tool.invoke.`,
+        };
+    }
+    if (code === 'NOT_AUTHENTICATED' || code === 'NOT_OPEN') {
+        return {
+            success: false,
+            error: `Peer "${peer}" is not currently connected. Use list_peers to check connection status.`,
+        };
+    }
+    if (combined.includes('TOOL_NOT_ALLOWED_FOR_PEER_INVOKE')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: tool is not in the peer-invoke allowlist.`,
+        };
+    }
+    if (combined.includes('TOOL_NOT_FLEET_SAFE')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: tool is not fleetSafe.`,
+        };
+    }
+    if (combined.includes('PEER_WORKSPACE_NOT_CONFIGURED')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: peer workspace is not configured for remote tool invoke.`,
+        };
+    }
+    if (combined.includes('PATH_OUTSIDE_PEER_WORKSPACE')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: path is outside the peer workspace.`,
+        };
+    }
+    if (combined.includes('UNKNOWN_PEER_TOOL')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: unknown peer tool.`,
+        };
+    }
+    if (combined.includes('PEER_SCOPE_DENIED')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: peer scope does not permit this tool.`,
+        };
+    }
+    if (combined.includes('METHOD_NOT_FOUND')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: peer.tool.invoke is not available (METHOD_NOT_FOUND).`,
+        };
+    }
+    if (combined.includes('INVALID_PARAMS')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: invalid peer.tool.invoke params.`,
+        };
+    }
+    if (combined.includes('RATE_LIMITED')) {
+        return {
+            success: false,
+            error: `Peer "${peer}" refused: rate limited.`,
+        };
+    }
+    const safe = redactPeerToolInvokeError(message);
+    return {
+        success: false,
+        error: `Peer "${peer}" failed: ${safe || 'unrecognized error'}.`,
+    };
+}
+async function withLocalTimeout(work, timeoutMs) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            const err = new Error(`peer.invoke REQUEST_TIMEOUT: peer.tool.invoke did not respond within ${timeoutMs}ms`);
+            err.code = 'REQUEST_TIMEOUT';
+            reject(err);
+        }, timeoutMs);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export async function executePeerToolInvoke(params) {
+    if (process.env.CODEBUDDY_PEER_ROLE === 'leaf') {
+        return {
+            success: false,
+            error: 'This Code Buddy is configured as a leaf peer (CODEBUDDY_PEER_ROLE=leaf) ' +
+                'and cannot invoke tools on other peers. Ask a non-leaf peer to run peer_tool_invoke.',
+        };
+    }
+    if (!params.peer || typeof params.peer !== 'string') {
+        return { success: false, error: 'peer_tool_invoke: "peer" parameter is required (string).' };
+    }
+    if (params.peer.length > MAX_PEER_ID_LENGTH || !PEER_ID_RE.test(params.peer)) {
+        return {
+            success: false,
+            error: 'peer_tool_invoke: "peer" must be 1–128 characters matching [A-Za-z0-9._-].',
+        };
+    }
+    if (!params.tool || typeof params.tool !== 'string') {
+        return { success: false, error: 'peer_tool_invoke: "tool" parameter is required (string).' };
+    }
+    if (params.tool.length > MAX_TOOL_NAME_LENGTH || !TOOL_NAME_RE.test(params.tool)) {
+        return {
+            success: false,
+            error: `peer_tool_invoke: "tool" must be a lowercase identifier up to ${MAX_TOOL_NAME_LENGTH} characters ` +
+                `(got ${JSON.stringify(params.tool.slice(0, 80))}). ` +
+                `Known read-only tools: ${DEFAULT_PEER_TOOL_INVOKE_TOOLS.join(', ')}.`,
+        };
+    }
+    if (params.args !== undefined && !isFlatToolArgs(params.args)) {
+        return {
+            success: false,
+            error: 'peer_tool_invoke: "args" must be a flat object of string/number/boolean values ' +
+                'with safe keys (no nested objects/arrays, no __proto__/constructor). ' +
+                'Paths are forwarded as given (not resolved on this host).',
+        };
+    }
+    const timeoutMs = clampPeerToolInvokeTimeout(params.timeoutMs);
+    const args = params.args ? { ...params.args } : {};
+    if (argsByteLength(args) > MAX_ARGS_BYTES) {
+        return {
+            success: false,
+            error: `peer_tool_invoke: "args" is too large (max ${MAX_ARGS_BYTES} bytes).`,
+        };
+    }
+    const reg = getFleetRegistry();
+    if (reg.size() === 0) {
+        return {
+            success: false,
+            error: 'No fleet peers connected. Ask the user to run /fleet listen <ws-url> --name <id> first ' +
+                'to add a peer Code Buddy to the fleet.',
+        };
+    }
+    const entry = reg.get(params.peer);
+    if (!entry) {
+        const ids = reg.ids().join(', ') || '(none)';
+        return {
+            success: false,
+            error: `Peer "${params.peer}" not found. Connected peers: ${ids}. ` +
+                `Use list_peers to see details.`,
+        };
+    }
+    if (typeof entry.listener.invokeTool !== 'function') {
+        return {
+            success: false,
+            error: `Peer "${params.peer}" listener has no invokeTool (peer.tool.invoke unavailable). ` +
+                `Use list_peers and try a peer whose listener supports remote read-only tools.`,
+        };
+    }
+    const allowed = await isToolAllowedOnPeer(params.tool, (method, requestParams, options) => entry.listener.request(method, requestParams, options));
+    if (!allowed.allowed) {
+        const extra = allowed.describeError
+            ? ` peer.describe failed: ${redactPeerToolInvokeError(allowed.describeError) || 'unrecognized error'}.`
+            : trustDescribeExtras()
+                ? ` Advertised extra tools: ${allowed.advertised.filter((n) => !DEFAULT_PEER_TOOL_INVOKE_TOOLS.includes(n)).join(', ') || '(none)'}.`
+                : ' Extra names from peer.describe require CODEBUDDY_PEER_TRUST_DESCRIBE=true.';
+        return {
+            success: false,
+            error: `peer_tool_invoke: tool "${params.tool}" is not in the local read-only set ` +
+                `(${DEFAULT_PEER_TOOL_INVOKE_TOOLS.join(', ')}) and was not advertised by peer.describe.${extra}`,
+        };
+    }
+    const t0 = Date.now();
+    try {
+        // keep listener this — call invokeTool on the listener object, never unbound.
+        const payload = await withLocalTimeout(entry.listener.invokeTool(params.tool, args, { timeoutMs }), timeoutMs);
+        const elapsedMs = Date.now() - t0;
+        const rawOutput = typeof payload?.output === 'string' ? payload.output : JSON.stringify(payload ?? {});
+        const { output, truncated } = truncateOutput(rawOutput);
+        const data = {
+            peer: params.peer,
+            tool: payload?.tool ?? params.tool,
+            output,
+            durationMs: payload?.durationMs ?? elapsedMs,
+            truncated: truncated || payload?.truncated === true,
+            elapsedMs,
+        };
+        return {
+            success: true,
+            output: [`[peer: ${params.peer}] [tool: ${params.tool}] [${elapsedMs}ms]`, output].join('\n'),
+            data,
+        };
+    }
+    catch (err) {
+        logger.debug('[peer-tool-invoke-tool] peer.tool.invoke error', {
+            peer: params.peer,
+            tool: params.tool,
+            message: err instanceof Error ? err.message : String(err),
+        });
+        return mapRemoteError(params.peer, err, timeoutMs);
+    }
+}
+//# sourceMappingURL=peer-tool-invoke-tool.js.map

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

@@ -1,9 +1,9 @@
 /**
  * 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 type { ToolResult } from '../../types/index.js';
 import type { ITool, ToolSchema, IToolMetadata, IValidationResult } from './types.js';
@@ -16,6 +16,15 @@ export declare class PeerDelegateTool implements ITool {
     getMetadata(): IToolMetadata;
     isAvailable(): boolean;
 }
+export declare class PeerToolInvokeTool implements ITool {
+    readonly name = "peer_tool_invoke";
+    readonly description: string;
+    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    getSchema(): ToolSchema;
+    validate(input: unknown): IValidationResult;
+    getMetadata(): IToolMetadata;
+    isAvailable(): boolean;
+}
 export declare class ListPeersTool implements ITool {
     readonly name = "list_peers";
     readonly description: string;

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

@@ -1,9 +1,9 @@
 /**
  * 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';
@@ -11,6 +11,7 @@ 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: ' +
@@ -128,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). ' +
@@ -500,7 +605,14 @@ export class FleetRoomTool {
     isAvailable() { return true; }
 }
 export function createFleetTools() {
-    return [new PeerDelegateTool(), new PeerChainTool(), new ListPeersTool(), new RoutePeerTool(), new FleetRoomTool()];
+    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/utils/config-validation/schema.d.ts

@@ -266,17 +266,17 @@ export declare const UserSettingsSchema: z.ZodObject<{
     theme: "default" | "minimal" | "auto" | "dark" | "light" | "neon" | "pastel" | "matrix" | "ocean" | "sunset" | "high-contrast";
     language: string;
     model?: string | undefined;
-    shell?: string | undefined;
     baseURL?: string | undefined;
+    shell?: string | undefined;
     apiKey?: string | undefined;
     editor?: string | undefined;
 }, {
     provider?: "custom" | "xai" | "anthropic" | "google" | "openai" | "lmstudio" | "ollama" | "local" | "mistral" | "gemini" | "grok" | "lm-studio" | "minimax" | "moonshot" | "claude" | "vllm" | "deepseek" | "qwen" | "openrouter" | "groq" | "together" | "fireworks" | "agy-cli" | "chatgpt" | "lemonade" | "ollama-cloud" | "novita" | "zai" | "kimi-coding" | "kimi-coding-cn" | "arcee" | "gmi" | "minimax-cn" | "alibaba" | "alibaba-coding-plan" | "kilocode" | "xiaomi" | "tencent-tokenhub" | "opencode-zen" | "opencode-go" | "huggingface" | "nvidia" | "omniroute" | "ai21" | "ant-ling" | "cerebras" | "cohere" | "deepinfra" | "featherless-ai" | "friendliai" | "hyperbolic" | "inception" | "inference-net" | "internlm" | "liquid" | "longcat" | "modelscope" | "nscale" | "openadapter" | "pioneer" | "reka" | "sambanova" | "sarvam" | "scaleway" | "tokenrouter" | "typhoon" | "zenmux" | "stepfun" | "azure" | "bedrock" | "copilot" | "novita-ai" | "glm" | "kimi" | "kimi-cn" | "moonshot-cn" | "arcee-ai" | "gmi-cloud" | "gmicloud" | "dashscope" | "alibaba-coding" | "kilo-code" | "mimo" | "tencent" | "tokenhub" | "opencode" | "hf" | "nvidia-nim" | undefined;
     model?: string | undefined;
+    baseURL?: string | undefined;
     models?: string[] | undefined;
     shell?: string | undefined;
     defaultModel?: string | undefined;
-    baseURL?: string | undefined;
     apiKey?: string | undefined;
     theme?: "default" | "minimal" | "auto" | "dark" | "light" | "neon" | "pastel" | "matrix" | "ocean" | "sunset" | "high-contrast" | undefined;
     editor?: string | undefined;

package/dist/utils/graceful-shutdown.d.ts

@@ -11,6 +11,14 @@
  * Intercepts signals: SIGINT (Ctrl+C), SIGTERM (kill), SIGHUP (terminal closed)
  */
 import { type Disposable } from './disposable.js';
+/**
+ * Exit code after a shutdown signal. Only an explicit headless run (`-p`, loop,
+ * try: CODEBUDDY_HEADLESS=true) reports SIGINT as 130 (USER_CANCELLED), so a
+ * script can tell an interruption from success. Servers and daemons whose stdout
+ * is merely not a TTY (systemd) keep exit 0: a normal SIGTERM stop must not be
+ * reported as a failure and trigger Restart=on-failure.
+ */
+export declare function signalExitCode(signal: string, env?: NodeJS.ProcessEnv): number;
 export interface ShutdownOptions {
     /** Maximum time to wait for shutdown in milliseconds (default: 30000) */
     timeoutMs: number;