@ouro.bot/cli 0.1.0-alpha.48 → 0.1.0-alpha.481

package/dist/repertoire/tools-travel.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.travelToolDefinitions = void 0;
+const travel_api_client_1 = require("./travel-api-client");
+const runtime_1 = require("../nerves/runtime");
+exports.travelToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "weather_lookup",
+                description: "Get current weather for a location. Provide either a city name or lat/lon coordinates.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        city: { type: "string", description: "City name (e.g. 'London', 'New York')" },
+                        lat: { type: "string", description: "Latitude (decimal)" },
+                        lon: { type: "string", description: "Longitude (decimal)" },
+                    },
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.travel_tool_call",
+                message: "weather_lookup invoked",
+                meta: { tool: "weather_lookup" },
+            });
+            try {
+                if (args.city) {
+                    const data = await (0, travel_api_client_1.getWeatherByCity)(args.city);
+                    return JSON.stringify(data, null, 2);
+                }
+                if (args.lat && args.lon) {
+                    const data = await (0, travel_api_client_1.getWeather)(parseFloat(args.lat), parseFloat(args.lon));
+                    return JSON.stringify(data, null, 2);
+                }
+                return "Please provide either a city name or lat/lon coordinates.";
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+                return `Weather lookup error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["city", "lat", "lon"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "travel_advisory",
+                description: "Get US State Department travel advisory for a country. Returns advisory level (1-4) and description.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        country_code: {
+                            type: "string",
+                            description: "ISO 3166 alpha-2 country code (e.g. 'US', 'GB', 'AF')",
+                        },
+                    },
+                    required: ["country_code"],
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.travel_tool_call",
+                message: "travel_advisory invoked",
+                meta: { tool: "travel_advisory" },
+            });
+            try {
+                const data = await (0, travel_api_client_1.getTravelAdvisory)(args.country_code.toUpperCase());
+                return JSON.stringify(data, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+                return `Travel advisory error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["country_code"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "geocode_search",
+                description: "Search for locations, addresses, or points of interest. Returns coordinates and display names.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query (e.g. 'Eiffel Tower', '123 Main St')" },
+                        near_lat: { type: "string", description: "Latitude to search near (for POI search)" },
+                        near_lon: { type: "string", description: "Longitude to search near (for POI search)" },
+                        radius_km: { type: "string", description: "Search radius in km (default 10)" },
+                    },
+                    required: ["query"],
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.travel_tool_call",
+                message: "geocode_search invoked",
+                meta: { tool: "geocode_search" },
+            });
+            try {
+                if (args.near_lat && args.near_lon) {
+                    const radiusKm = args.radius_km ? parseFloat(args.radius_km) : undefined;
+                    const data = await (0, travel_api_client_1.searchPOI)(args.query, parseFloat(args.near_lat), parseFloat(args.near_lon), radiusKm);
+                    return JSON.stringify(data, null, 2);
+                }
+                const data = await (0, travel_api_client_1.geocode)(args.query);
+                return JSON.stringify(data, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+                return `Geocode error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["query"],
+    },
+];

package/dist/repertoire/tools-user-profile.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userProfileToolDefinitions = void 0;
+const user_profile_1 = require("./user-profile");
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot access user profile.";
+    }
+    if (ctx.context.friend.trustLevel !== "family") {
+        return "user profile access requires family trust level.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+exports.userProfileToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_store",
+                description: "Store or update user profile fields (legal name, DOB, passport, etc.) in the agent's vault. Fields are merged with any existing profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        fields: {
+                            type: "string",
+                            description: 'JSON object with profile fields to store/update. Keys: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.',
+                        },
+                    },
+                    required: ["fields"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_store",
+                message: "user_profile_store invoked",
+                meta: { tool: "user_profile_store" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            let fields;
+            try {
+                fields = JSON.parse(args.fields);
+            }
+            catch {
+                return "invalid JSON in fields parameter.";
+            }
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                await (0, user_profile_1.updateUserProfileFields)(guard.friendId, fields, store);
+                return `profile fields stored for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: updateUserProfileFields errors are always Error instances @preserve */
+                return `failed to store profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["fields"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_get",
+                description: "Retrieve a specific field from a user's profile. Only returns the requested field, never the full profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        field: {
+                            type: "string",
+                            description: "The profile field to retrieve: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.",
+                        },
+                    },
+                    required: ["field"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_get",
+                message: "user_profile_get invoked",
+                meta: { tool: "user_profile_get", field: args.field },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const value = await (0, user_profile_1.getUserProfileField)(guard.friendId, args.field, store);
+                if (value === undefined) {
+                    return `field "${args.field}" is not set on the profile.`;
+                }
+                /* v8 ignore next -- platform-dependent v8 branch counting on ternary @preserve */
+                return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: getUserProfileField errors are always Error instances @preserve */
+                return `failed to get profile field: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["field"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_delete",
+                description: "Delete a user's entire profile from the vault. This is irreversible. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async (_args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_delete",
+                message: "user_profile_delete invoked",
+                meta: { tool: "user_profile_delete" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const deleted = await (0, user_profile_1.deleteUserProfile)(guard.friendId, store);
+                return deleted
+                    ? `profile deleted for ${guard.friendId}.`
+                    : `no profile found for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: deleteUserProfile errors are always Error instances @preserve */
+                return `failed to delete profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: [],
+    },
+];

package/dist/repertoire/tools-vault.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+exports.vaultToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_setup",
+                description: "Set up the agent's credential vault. Creates a Bitwarden account on the configured Vaultwarden server. One-time operation — idempotent if vault already exists.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async () => {
+            const agentName = (0, identity_1.getAgentName)();
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_setup invoked",
+                meta: { tool: "vault_setup", agentName },
+            });
+            return [
+                "Vault setup is human-required.",
+                "",
+                "Why I cannot do it here:",
+                "  Creating or unlocking a vault requires secret entry that must stay out of agent context.",
+                "",
+                "Do this in a terminal:",
+                `  ouro vault create --agent ${agentName}`,
+                `  ouro vault unlock --agent ${agentName}`,
+            ].join("\n");
+        },
+        summaryKeys: [],
+    },
+];

package/dist/repertoire/tools.js

@@ -1,43 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REMOTE_BLOCKED_LOCAL_TOOLS = exports.finalAnswerTool = exports.tools = void 0;
+exports.surfaceToolDef = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
+exports.resetMcpDefinitions = resetMcpDefinitions;
 exports.getToolsForChannel = getToolsForChannel;
-exports.isConfirmationRequired = isConfirmationRequired;
 exports.execTool = execTool;
 exports.summarizeArgs = summarizeArgs;
+exports.buildToolResultSummary = buildToolResultSummary;
 const tools_base_1 = require("./tools-base");
 const tools_teams_1 = require("./tools-teams");
 const tools_bluebubbles_1 = require("./tools-bluebubbles");
 const ado_semantic_1 = require("./ado-semantic");
 const tools_github_1 = require("./tools-github");
-const types_1 = require("../mind/friends/types");
-const channel_1 = require("../mind/friends/channel");
+const tools_bundle_1 = require("./tools-bundle");
 const runtime_1 = require("../nerves/runtime");
+const guardrails_1 = require("./guardrails");
+const identity_1 = require("../heart/identity");
+const tools_surface_1 = require("./tools-surface");
+const mcp_tools_1 = require("./mcp-tools");
+function safeGetAgentRoot() {
+    try {
+        return (0, identity_1.getAgentRoot)();
+    }
+    catch {
+        return undefined;
+    }
+}
 // Re-export types and constants used by the rest of the codebase
 var tools_base_2 = require("./tools-base");
 Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_base_2.tools; } });
-Object.defineProperty(exports, "finalAnswerTool", { enumerable: true, get: function () { return tools_base_2.finalAnswerTool; } });
+Object.defineProperty(exports, "settleTool", { enumerable: true, get: function () { return tools_base_2.settleTool; } });
+Object.defineProperty(exports, "observeTool", { enumerable: true, get: function () { return tools_base_2.observeTool; } });
+Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_base_2.ponderTool; } });
+Object.defineProperty(exports, "restTool", { enumerable: true, get: function () { return tools_base_2.restTool; } });
+// Re-export surface tool schema for consumers (e.g. heart/core.ts)
+var tools_surface_2 = require("./tools-surface");
+Object.defineProperty(exports, "surfaceToolDef", { enumerable: true, get: function () { return tools_surface_2.surfaceToolDef; } });
 // All tool definitions in a single registry
-const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
-/** Tool names blocked for untrusted remote contexts. Shared with prompt.ts for restriction messaging. */
-exports.REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "edit_file", "glob", "grep"]);
-function isTrustedRemoteContext(context) {
-    if (!context?.friend || !(0, channel_1.isRemoteChannel)(context.channel))
-        return false;
-    return (0, types_1.isTrustedLevel)(context.friend.trustLevel);
+const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions, ...tools_bundle_1.bundleToolDefinitions, tools_surface_1.surfaceToolDefinition];
+// MCP tool definitions — populated each time getToolsForChannel() is called with an mcpManager.
+// Kept separate from allDefinitions so execTool can find them.
+let mcpDefinitions = [];
+/** Exported for testing — reset the MCP definitions cache. */
+function resetMcpDefinitions() {
+    mcpDefinitions = [];
 }
-function shouldBlockLocalTools(capabilities, context) {
-    if (!(0, channel_1.isRemoteChannel)(capabilities))
-        return false;
-    return !isTrustedRemoteContext(context);
-}
-function blockedLocalToolMessage() {
-    return "I can't do that because my trust level with you isn't high enough for local shell/file operations. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
-}
-function baseToolsForCapabilities(capabilities, context) {
-    if (!shouldBlockLocalTools(capabilities, context))
-        return tools_base_1.tools;
-    return tools_base_1.tools.filter((tool) => !exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
+function baseToolsForCapabilities() {
+    // Use baseToolDefinitions at call time so dynamically-added tools are included
+    return tools_base_1.baseToolDefinitions.map((d) => d.tool);
 }
 // Apply a single tool preference to a tool schema, returning a new object.
 function applyPreference(tool, pref) {
@@ -49,53 +58,79 @@ function applyPreference(tool, pref) {
         },
     };
 }
+// Filter out tools whose requiredCapability is not in the provider's capability set.
+// Uses baseToolDefinitions at call time so dynamically-added tools are included.
+// Only base tools can have requiredCapability (integration tools do not).
+function filterByCapability(toolList, providerCapabilities) {
+    return toolList.filter((tool) => {
+        const def = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === tool.function.name);
+        if (!def?.requiredCapability)
+            return true;
+        return providerCapabilities?.has(def.requiredCapability) === true;
+    });
+}
 // Return the appropriate tools list based on channel capabilities.
 // Base tools (no integration) are always included.
 // Teams/integration tools are included only if their integration is in availableIntegrations.
 // When toolPreferences is provided, matching preferences are appended to tool descriptions.
-function getToolsForChannel(capabilities, toolPreferences, context) {
-    const baseTools = baseToolsForCapabilities(capabilities, context);
+// When providerCapabilities is provided, tools with requiredCapability are filtered.
+function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities, mcpManager, _chatModel) {
+    const baseTools = baseToolsForCapabilities();
     const bluebubblesTools = capabilities?.channel === "bluebubbles"
         ? tools_bluebubbles_1.bluebubblesToolDefinitions.map((d) => d.tool)
         : [];
+    let result;
     if (!capabilities || capabilities.availableIntegrations.length === 0) {
-        return [...baseTools, ...bluebubblesTools];
+        result = [...baseTools, ...bluebubblesTools];
     }
-    const available = new Set(capabilities.availableIntegrations);
-    const channelDefs = [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
-    // Include tools whose integration is available, plus channel tools with no integration gate (e.g. teams_send_message)
-    const integrationDefs = channelDefs.filter((d) => d.integration ? available.has(d.integration) : capabilities.channel === "teams");
-    if (!toolPreferences || Object.keys(toolPreferences).length === 0) {
-        return [...baseTools, ...bluebubblesTools, ...integrationDefs.map((d) => d.tool)];
+    else {
+        const available = new Set(capabilities.availableIntegrations);
+        const channelDefs = [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
+        // Include tools whose integration is available, plus channel tools with no integration gate (e.g. teams_send_message)
+        const integrationDefs = channelDefs.filter((d) => d.integration ? available.has(d.integration) : capabilities.channel === "teams");
+        if (!toolPreferences || Object.keys(toolPreferences).length === 0) {
+            result = [...baseTools, ...bluebubblesTools, ...integrationDefs.map((d) => d.tool)];
+        }
+        else {
+            // Build a map of integration -> preference text for fast lookup
+            const prefMap = new Map();
+            for (const [key, value] of Object.entries(toolPreferences)) {
+                prefMap.set(key, value);
+            }
+            // Apply preferences to matching integration tools (new objects, no mutation)
+            // d.integration is guaranteed truthy -- integrationDefs are pre-filtered above
+            const enrichedIntegrationTools = integrationDefs.map((d) => {
+                const pref = prefMap.get(d.integration);
+                return pref ? applyPreference(d.tool, pref) : d.tool;
+            });
+            result = [...baseTools, ...bluebubblesTools, ...enrichedIntegrationTools];
+        }
     }
-    // Build a map of integration -> preference text for fast lookup
-    const prefMap = new Map();
-    for (const [key, value] of Object.entries(toolPreferences)) {
-        prefMap.set(key, value);
+    // Append first-class MCP tools when mcpManager is provided
+    if (mcpManager) {
+        mcpDefinitions = (0, mcp_tools_1.mcpToolsAsDefinitions)(mcpManager);
+        const mcpSchemas = mcpDefinitions.map((d) => d.tool);
+        result = [...result, ...mcpSchemas];
     }
-    // Apply preferences to matching integration tools (new objects, no mutation)
-    // d.integration is guaranteed truthy -- integrationDefs are pre-filtered above
-    const enrichedIntegrationTools = integrationDefs.map((d) => {
-        const pref = prefMap.get(d.integration);
-        return pref ? applyPreference(d.tool, pref) : d.tool;
-    });
-    return [...baseTools, ...bluebubblesTools, ...enrichedIntegrationTools];
+    return filterByCapability(result, providerCapabilities);
 }
-// Check whether a tool requires user confirmation before execution.
-// Reads from ToolDefinition.confirmationRequired instead of a separate Set.
-function isConfirmationRequired(toolName) {
-    const def = allDefinitions.find((d) => d.tool.function.name === toolName);
-    return def?.confirmationRequired === true;
+// Look up a tool definition from the combined registry (native + MCP).
+function findDefinition(toolName) {
+    return allDefinitions.find((d) => d.tool.function.name === toolName)
+        ?? mcpDefinitions.find((d) => d.tool.function.name === toolName);
+}
+function normalizeGuardArgs(_name, args) {
+    return args;
 }
 async function execTool(name, args, ctx) {
     (0, runtime_1.emitNervesEvent)({
         event: "tool.start",
         component: "tools",
         message: "tool execution started",
-        meta: { name },
+        meta: { name, ...(name === "shell" && args.command ? { command: args.command } : {}) },
     });
-    // Look up from combined registry
-    const def = allDefinitions.find((d) => d.tool.function.name === name);
+    // Look up from combined registry (native + MCP)
+    const def = findDefinition(name);
     if (!def) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -106,16 +141,26 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    if (shouldBlockLocalTools(ctx?.context?.channel, ctx?.context) && exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
-        const message = blockedLocalToolMessage();
+    // Guardrail check: structural + trust-level
+    const mcpDef = mcpDefinitions.find((d) => d.tool.function.name === name);
+    const guardContext = {
+        readPaths: tools_base_1.editFileReadTracker,
+        trustLevel: ctx?.context?.friend?.trustLevel,
+        agentRoot: safeGetAgentRoot(),
+        ...(mcpDef?.mcpServer ? { mcpServerName: mcpDef.mcpServer } : {}),
+        ...(ctx?.context?.isGroupChat !== undefined ? { isGroupChat: (ctx?.context).isGroupChat } : {}),
+    };
+    const guardArgs = normalizeGuardArgs(name, args);
+    const guardResult = (0, guardrails_1.guardInvocation)(name, guardArgs, guardContext);
+    if (!guardResult.allowed) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
-            event: "tool.error",
+            event: "tool.guardrail_block",
             component: "tools",
-            message: "blocked local tool in remote channel",
-            meta: { name, channel: ctx?.context?.channel?.channel },
+            message: "guardrail blocked tool execution",
+            meta: { name, reason: guardResult.reason },
         });
-        return message;
+        return guardResult.reason;
     }
     try {
         const result = await def.handler(args, ctx);
@@ -159,61 +204,47 @@ function summarizeUnknownArgs(args) {
     return summarizeKeyValues(args, keys);
 }
 function summarizeArgs(name, args) {
-    // Check teams tools first
-    const teamsSummary = (0, tools_teams_1.summarizeTeamsArgs)(name, args);
-    if (teamsSummary !== undefined)
-        return teamsSummary;
-    // Check github tools
-    const githubSummary = (0, tools_github_1.summarizeGithubArgs)(name, args);
-    if (githubSummary !== undefined)
-        return githubSummary;
-    // Base tools
-    if (name === "read_file" || name === "write_file")
-        return summarizeKeyValues(args, ["path"]);
-    if (name === "edit_file")
-        return summarizeKeyValues(args, ["path"]);
-    if (name === "glob")
-        return summarizeKeyValues(args, ["pattern", "cwd"]);
-    if (name === "grep")
-        return summarizeKeyValues(args, ["pattern", "path", "include"]);
-    if (name === "shell")
-        return summarizeKeyValues(args, ["command"]);
-    if (name === "load_skill")
-        return summarizeKeyValues(args, ["name"]);
-    if (name === "coding_spawn")
-        return summarizeKeyValues(args, ["runner", "workdir", "taskRef"]);
-    if (name === "coding_status")
-        return summarizeKeyValues(args, ["sessionId"]);
-    if (name === "coding_tail")
-        return summarizeKeyValues(args, ["sessionId"]);
-    if (name === "coding_send_input")
-        return summarizeKeyValues(args, ["sessionId", "input"]);
-    if (name === "coding_kill")
-        return summarizeKeyValues(args, ["sessionId"]);
-    if (name === "bluebubbles_set_reply_target")
-        return summarizeKeyValues(args, ["target", "threadOriginatorGuid"]);
-    if (name === "claude")
-        return summarizeKeyValues(args, ["prompt"]);
-    if (name === "web_search")
-        return summarizeKeyValues(args, ["query"]);
-    if (name === "memory_search")
-        return summarizeKeyValues(args, ["query"]);
-    if (name === "memory_save")
-        return summarizeKeyValues(args, ["text", "about"]);
-    if (name === "get_friend_note")
-        return summarizeKeyValues(args, ["friendId"]);
-    if (name === "save_friend_note") {
-        return summarizeKeyValues(args, ["type", "key", "content"]);
+    const def = findDefinition(name);
+    if (def && def.summaryKeys !== undefined) {
+        return summarizeKeyValues(args, def.summaryKeys);
     }
-    if (name === "ado_backlog_list")
-        return summarizeKeyValues(args, ["organization", "project"]);
-    if (name === "ado_batch_update")
-        return summarizeKeyValues(args, ["organization", "project"]);
-    if (name === "ado_create_epic" || name === "ado_create_issue")
-        return summarizeKeyValues(args, ["organization", "project", "title"]);
-    if (name === "ado_move_items")
-        return summarizeKeyValues(args, ["organization", "project", "workItemIds"]);
-    if (name === "ado_restructure_backlog")
-        return summarizeKeyValues(args, ["organization", "project"]);
     return summarizeUnknownArgs(args);
 }
+/**
+ * Build an enriched tool result summary for display on remote channels.
+ * For recognized tools, includes result-derived info (diff stats, exit codes, etc.).
+ * Falls back to arg-based summary for unrecognized tools.
+ */
+function buildToolResultSummary(name, args, _result, success) {
+    /* v8 ignore start -- branches: ?? fallbacks and ternaries in tool summary formatting @preserve */
+    switch (name) {
+        case "edit_file": {
+            if (!success)
+                return summarizeArgs(name, args);
+            const addedLines = (args.new_string ?? "").split("\n").length;
+            const removedLines = (args.old_string ?? "").split("\n").length;
+            return `+${addedLines} -${removedLines} lines in ${args.path ?? "unknown"}`;
+        }
+        case "shell": {
+            const cmd = args.command ?? "?";
+            const exitCode = success ? 0 : 1;
+            return `$ ${cmd} (exit ${exitCode})`;
+        }
+        case "read_file":
+            return `path=${args.path ?? "unknown"}`;
+        case "write_file":
+            return `path=${args.path ?? "unknown"}`;
+        case "glob":
+            return `pattern=${args.pattern ?? "?"} ${args.cwd ? `cwd=${args.cwd}` : ""}`.trim();
+        case "grep":
+            return `pattern=${args.pattern ?? "?"} ${args.path ? `path=${args.path}` : ""}`.trim();
+        case "coding_spawn": {
+            const taskRef = args.taskRef ?? "unknown";
+            const status = success ? "spawned" : "failed";
+            return `${taskRef} -> ${status}`;
+        }
+        default:
+            return summarizeArgs(name, args);
+    }
+    /* v8 ignore stop */
+}