@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.800

package/dist/repertoire/tools.js

@@ -1,29 +1,136 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.teamsTools = exports.finalAnswerTool = exports.tools = void 0;
+exports.surfaceToolDef = exports.speakTool = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
+exports.resetMcpDefinitions = resetMcpDefinitions;
+exports.getSanctuaryRelationshipTools = getSanctuaryRelationshipTools;
 exports.getToolsForChannel = getToolsForChannel;
-exports.isConfirmationRequired = isConfirmationRequired;
+exports.resolveToolDefinition = resolveToolDefinition;
+exports.approvalPolicyForToolName = approvalPolicyForToolName;
+exports.classifyApprovalForInvocation = classifyApprovalForInvocation;
+exports.approvalPolicyForInvocation = approvalPolicyForInvocation;
+exports.shellRiskProfile = shellRiskProfile;
+exports.riskProfileForTool = riskProfileForTool;
+exports.riskProfileForToolName = riskProfileForToolName;
 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 tools_bundle_1 = require("./tools-bundle");
 const runtime_1 = require("../nerves/runtime");
+const guardrails_1 = require("./guardrails");
+const identity_1 = require("../heart/identity");
+const store_1 = require("../commerce/store");
+const tools_surface_1 = require("./tools-surface");
+const mcp_tools_1 = require("./mcp-tools");
+const tools_voice_1 = require("./tools-voice");
+const shell_sessions_1 = require("./shell-sessions");
+const tools_unraid_1 = require("./tools-unraid");
+const tools_flow_1 = require("./tools-flow");
+const tools_steward_policy_1 = require("./tools-steward-policy");
+const steward_policy_1 = require("../heart/steward-policy");
+function safeGetAgentRoot() {
+    try {
+        return (0, identity_1.getAgentRoot)();
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSanctuaryAgent() {
+    try {
+        return (0, identity_1.getAgentName)() === "sanctuary";
+    }
+    catch {
+        return false;
+    }
+}
+const SANCTUARY_RELATIONSHIP_BASE_TOOLS = new Set([
+    "external_event_disposition",
+    "query_active_work",
+    "save_friend_note",
+    "telegram_contact_manage",
+    "query_cares",
+    "care_manage",
+    "await_condition",
+    "resolve_await",
+    "cancel_await",
+    "list_recent_attachments",
+    "materialize_attachment",
+    "describe_image",
+    "send_message",
+]);
+const SANCTUARY_TELEGRAM_SURFACE = new Set([
+    "query_active_work",
+    "save_friend_note",
+    "telegram_contact_manage",
+    "query_cares",
+    "care_manage",
+    "await_condition",
+    "resolve_await",
+    "cancel_await",
+    "list_recent_attachments",
+    "materialize_attachment",
+    "describe_image",
+    ...tools_unraid_1.unraidToolDefinitions.map((definition) => definition.tool.function.name),
+    "steward_policy_manage",
+    "ponder",
+    "settle",
+    "speak",
+]);
 // 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; } });
-var tools_teams_2 = require("./tools-teams");
-Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function () { return tools_teams_2.teamsTools; } });
+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; } });
+Object.defineProperty(exports, "speakTool", { enumerable: true, get: function () { return tools_base_2.speakTool; } });
+// 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_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
-const REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "git_commit", "gh_cli"]);
-function baseToolsForCapabilities(capabilities) {
-    const isRemoteChannel = capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
-    if (!isRemoteChannel)
-        return tools_base_1.tools;
-    return tools_base_1.tools.filter((tool) => !REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
+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_voice_1.voiceToolDefinitions, ...tools_unraid_1.unraidToolDefinitions, tools_steward_policy_1.stewardPolicyToolDefinition, tools_surface_1.surfaceToolDefinition];
+const COMMERCE_AUTHORITY_TOOLS = new Set(["stripe_create_card", "flight_hold", "flight_book"]);
+// 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 baseToolsForCapabilities() {
+    // Use baseToolDefinitions at call time so dynamically-added tools are included
+    return tools_base_1.baseToolDefinitions.map((d) => d.tool);
+}
+function uniqueToolSchemas(tools) {
+    const seen = new Set();
+    return tools.filter((tool) => {
+        if (seen.has(tool.function.name))
+            return false;
+        seen.add(tool.function.name);
+        return true;
+    });
+}
+/**
+ * Resolve Sanctuary relationship tools from one canonical definition pool.
+ * Durable relationship profiles can only reduce this surface; they cannot
+ * introduce an arbitrary base tool by naming it in configuration.
+ */
+function getSanctuaryRelationshipTools(advertisedToolNames) {
+    const advertised = new Set(advertisedToolNames);
+    return uniqueToolSchemas([
+        ...tools_base_1.baseToolDefinitions.filter((definition) => SANCTUARY_RELATIONSHIP_BASE_TOOLS.has(definition.tool.function.name)).map((definition) => definition.tool),
+        ...tools_unraid_1.unraidToolDefinitions.map((definition) => definition.tool),
+        tools_steward_policy_1.stewardPolicyToolDefinition.tool,
+        tools_flow_1.ponderTool,
+        tools_flow_1.restTool,
+        tools_flow_1.settleTool,
+        tools_flow_1.speakTool,
+    ]).filter((tool) => advertised.has(tool.function.name));
 }
 // Apply a single tool preference to a tool schema, returning a new object.
 function applyPreference(tool, pref) {
@@ -35,48 +142,210 @@ 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) {
-    const baseTools = baseToolsForCapabilities(capabilities);
+// When providerCapabilities is provided, tools with requiredCapability are filtered.
+function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities, mcpManager, _chatModel) {
+    if (capabilities?.channel === "telegram" && isSanctuaryAgent()) {
+        return getSanctuaryRelationshipTools([...SANCTUARY_TELEGRAM_SURFACE]);
+    }
+    const baseTools = baseToolsForCapabilities();
+    const bluebubblesTools = capabilities?.channel === "bluebubbles"
+        ? tools_bluebubbles_1.bluebubblesToolDefinitions.map((d) => d.tool)
+        : [];
+    const voiceTools = capabilities?.channel === "voice"
+        ? tools_voice_1.voiceToolDefinitions.map((d) => d.tool)
+        : [];
+    let result;
     if (!capabilities || capabilities.availableIntegrations.length === 0) {
-        return baseTools;
-    }
-    const available = new Set(capabilities.availableIntegrations);
-    const integrationDefs = [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions].filter((d) => d.integration && available.has(d.integration));
-    if (!toolPreferences || Object.keys(toolPreferences).length === 0) {
-        return [...baseTools, ...integrationDefs.map((d) => d.tool)];
-    }
-    // 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;
-    });
-    return [...baseTools, ...enrichedIntegrationTools];
+        result = [...baseTools, ...bluebubblesTools, ...voiceTools];
+    }
+    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, ...voiceTools, ...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, ...voiceTools, ...enrichedIntegrationTools];
+        }
+    }
+    // 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];
+    }
+    return filterByCapability(result, providerCapabilities);
+}
+// Look up a tool definition from the live combined registry (native + MCP).
+// The base registry is intentionally consulted at call time so tests and
+// runtime extensions cannot leave execution metadata behind a stale snapshot.
+function resolveToolDefinition(toolName) {
+    return tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === toolName)
+        ?? allDefinitions.find((d) => d.tool.function.name === toolName)
+        ?? mcpDefinitions.find((d) => d.tool.function.name === toolName);
+}
+function approvalPolicyForToolName(name, args) {
+    return resolveToolDefinition(name)?.approvalPolicy?.(args) ?? { kind: "not_required" };
+}
+async function routineActionInvocation(name, args, ctx) {
+    const target = typeof args.container === "string" ? args.container : "";
+    if (name !== "unraid_restart_container" || !ctx?.agentRoot || !(0, tools_base_1.routineActionRequester)(ctx) || !target)
+        return null;
+    const relationshipAuthorization = ctx.relationshipAuthorization;
+    if (!relationshipAuthorization)
+        return null;
+    let authorization;
+    try {
+        authorization = await relationshipAuthorization.authorizeTool(name, args);
+    }
+    catch {
+        return null;
+    }
+    if (!authorization.allowed || !Number.isInteger(authorization.profileVersion) || Number(authorization.profileVersion) < 1)
+        return null;
+    const key = `unraid.restart:${target}`;
+    const decision = (0, steward_policy_1.inspectRoutineActionGrant)(ctx.agentRoot, { key, action: "unraid.container.restart", target });
+    return decision.allowed ? { key, target, expectedPolicyVersion: decision.policyVersion } : null;
+}
+async function classifyApprovalForInvocation(name, args, ctx) {
+    const fallback = approvalPolicyForToolName(name, args);
+    if (name !== "unraid_restart_container" || fallback.kind !== "required")
+        return { policy: fallback };
+    const routineActionSelection = await routineActionInvocation(name, args, ctx);
+    return routineActionSelection ? { policy: { kind: "not_required" }, routineActionSelection } : { policy: fallback };
+}
+async function approvalPolicyForInvocation(name, args, ctx) {
+    return (await classifyApprovalForInvocation(name, args, ctx)).policy;
+}
+const findDefinition = resolveToolDefinition;
+function normalizeGuardArgs(_name, args) {
+    return args;
 }
-// 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;
+const READ_ONLY_OURO_SHELL_COMMANDS = new Set([
+    "help",
+    "-h",
+    "--help",
+    "-v",
+    "--version",
+    "status",
+    "whoami",
+    "versions",
+    "changelog",
+    "mailbox",
+    "inner",
+    "thoughts",
+    "check",
+    "session list",
+    "mcp list",
+    "config models",
+    "auth verify",
+    "vault status",
+    "vault config status",
+    "vault item status",
+    "vault item list",
+]);
+function shellTokens(command) {
+    return command.trim().split(/\s+/).filter(Boolean);
+}
+function ouroShellRiskReason(command) {
+    const tokens = shellTokens(command);
+    if (tokens[0] !== "ouro")
+        return null;
+    const first = tokens[1] ?? "";
+    const second = tokens[2] ?? "";
+    const third = tokens[3] ?? "";
+    const twoWord = second ? `${first} ${second}` : first;
+    const threeWord = third ? `${twoWord} ${third}` : twoWord;
+    if (READ_ONLY_OURO_SHELL_COMMANDS.has(threeWord)
+        || READ_ONLY_OURO_SHELL_COMMANDS.has(twoWord)
+        || READ_ONLY_OURO_SHELL_COMMANDS.has(first)) {
+        return null;
+    }
+    const hint = first === "restart_runtime"
+        ? " Hint: use the restart_runtime tool instead of shell."
+        : "";
+    return `ouro CLI command may mutate runtime/config state or be unavailable from shell.${hint}`;
+}
+function shellRiskProfile(args) {
+    const command = String(args.command);
+    const destructive = (0, shell_sessions_1.detectDestructivePatterns)(command);
+    if (destructive.length > 0) {
+        return { mutates: "external_side_effect", risk: "high", reason: `destructive shell pattern: ${destructive.join(", ")}` };
+    }
+    const ouroRiskReason = ouroShellRiskReason(command);
+    if (ouroRiskReason) {
+        return { mutates: "external_side_effect", risk: "high", reason: ouroRiskReason };
+    }
+    if (/(^|\s)(rm|mv|cp|touch|mkdir|rmdir)\b/.test(command)
+        || /(^|\s)(npm|pnpm|yarn)\s+(install|add|remove|update|upgrade)\b/.test(command)
+        || /(^|\s)git\s+(add|apply|checkout|clean|commit|merge|pull|push|rebase|reset|restore|switch)\b/.test(command)
+        || /(^|\s)(sed\s+-i|perl\s+-pi)\b/.test(command)
+        || /(^|\s)(tee|truncate)\b/.test(command)
+        || /(^|[^<])>>?\s*\S+/.test(command)) {
+        return { mutates: "external_side_effect", risk: "high", reason: "shell command appears to mutate files, packages, git state, or external state" };
+    }
+    return { mutates: "none", risk: "low" };
+}
+function riskProfileForTool(def, name, args) {
+    if (name === "shell")
+        return shellRiskProfile(args);
+    if (typeof def.riskProfile === "function")
+        return def.riskProfile(args);
+    return def.riskProfile ?? { mutates: "none", risk: "low" };
+}
+function riskProfileForToolName(name, args) {
+    const def = findDefinition(name);
+    return def ? riskProfileForTool(def, name, args) : null;
+}
+function orientationHoldMessage(name, profile, reason) {
+    return `orientation hold: ${reason} Available: orientation_get plus read-only inspection tools like trip_status, query_session, read_config, read_file, grep, search_facts, consult_diary, and consult_notes. Resolve the referent/correction, then retry ${name} if the action is still correct. Blocked ${mutationKindsFor(profile).join(", ")}. ${profile.reason}.`;
+}
+function mutationKindsFor(profile) {
+    const mutates = profile.mutates;
+    return typeof mutates === "string" ? [mutates] : [...mutates];
+}
+function orientationPolicyBlocks(profile, blockedMutationKinds) {
+    if (profile.risk !== "high")
+        return false;
+    return mutationKindsFor(profile).some((kind) => blockedMutationKinds.includes(kind));
 }
 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",
@@ -87,20 +356,86 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    const isRemoteChannel = ctx?.context?.channel?.channel === "teams" || ctx?.context?.channel?.channel === "bluebubbles";
-    if (isRemoteChannel && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
-        const message = "I can't do that from here because I'm talking to multiple people in a shared remote channel, and local shell/file/git/gh operations could let conversations interfere with each other. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
+    const relationshipDecision = await ctx?.relationshipAuthorization?.authorizeTool(name, args);
+    if (relationshipDecision && !relationshipDecision.allowed) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
-            event: "tool.error",
+            event: "tool.relationship_authorization_block",
+            component: "tools",
+            message: "relationship authorization blocked tool execution",
+            meta: { name, reason: relationshipDecision.reason },
+        });
+        return `relationship authorization required: ${relationshipDecision.reason}`;
+    }
+    const riskProfile = riskProfileForTool(def, name, args);
+    const orientationPolicy = ctx?.orientationFrame?.actionPolicy;
+    if (orientationPolicy?.mode === "correction_hold"
+        && orientationPolicyBlocks(riskProfile, orientationPolicy.blockedMutationKinds)) {
+        const reason = orientationPolicy.reason;
+        const message = orientationHoldMessage(name, riskProfile, reason);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "tool.orientation_hold_block",
             component: "tools",
-            message: "blocked local tool in remote channel",
-            meta: { name, channel: ctx?.context?.channel?.channel },
+            message: "orientation hold blocked high-risk tool execution",
+            meta: { name, mutates: mutationKindsFor(riskProfile), reason },
         });
         return message;
     }
+    // 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: ctx?.agentRoot ?? safeGetAgentRoot(),
+        friendId: ctx?.context?.friend?.id,
+        ...(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.guardrail_block",
+            component: "tools",
+            message: "guardrail blocked tool execution",
+            meta: { name, reason: guardResult.reason },
+        });
+        return guardResult.reason;
+    }
+    const commerceReservation = COMMERCE_AUTHORITY_TOOLS.has(name) && guardContext.agentRoot
+        ? (0, store_1.reserveCommerceAuthority)({
+            agentRoot: guardContext.agentRoot,
+            token: guardArgs.commerce_authority,
+            toolName: name,
+            args: guardArgs,
+            friendId: guardContext.friendId,
+        })
+        : null;
+    if (commerceReservation && !commerceReservation.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "tool.guardrail_block",
+            component: "tools",
+            message: "guardrail blocked tool execution",
+            meta: { name, reason: commerceReservation.reason },
+        });
+        return `commerce authority required: ${commerceReservation.reason}`;
+    }
+    const authorizedContext = ctx;
+    const toolContext = commerceReservation?.ok
+        ? {
+            ...authorizedContext,
+            agentRoot: guardContext.agentRoot,
+            commerceAuthority: {
+                checkoutId: commerceReservation.checkoutId,
+                reservationToken: commerceReservation.reservationToken,
+            },
+        }
+        : authorizedContext;
     try {
-        const result = await def.handler(args, ctx);
+        const result = await def.handler(args, toolContext);
         (0, runtime_1.emitNervesEvent)({
             event: "tool.end",
             component: "tools",
@@ -119,6 +454,22 @@ async function execTool(name, args, ctx) {
         });
         throw error;
     }
+    finally {
+        if (commerceReservation?.ok && guardContext.agentRoot) {
+            try {
+                (0, store_1.releaseReservedCommerceAuthority)({
+                    agentRoot: guardContext.agentRoot,
+                    checkoutId: commerceReservation.checkoutId,
+                    reservationToken: commerceReservation.reservationToken,
+                    toolName: name,
+                    friendId: guardContext.friendId,
+                });
+            }
+            catch {
+                /* v8 ignore next -- external tool result/error should not be masked by best-effort reservation cleanup @preserve */
+            }
+        }
+    }
 }
 function summarizeKeyValues(args, keys, maxValueLength = 60) {
     const parts = [];
@@ -141,59 +492,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 === "shell")
-        return summarizeKeyValues(args, ["command"]);
-    if (name === "list_directory")
-        return summarizeKeyValues(args, ["path"]);
-    if (name === "git_commit")
-        return summarizeKeyValues(args, ["message"]);
-    if (name === "gh_cli")
-        return summarizeKeyValues(args, ["command"]);
-    if (name === "load_skill")
-        return summarizeKeyValues(args, ["name"]);
-    if (name === "task_create")
-        return summarizeKeyValues(args, ["title", "type", "category"]);
-    if (name === "task_update_status")
-        return summarizeKeyValues(args, ["name", "status"]);
-    if (name === "task_board_status")
-        return summarizeKeyValues(args, ["status"]);
-    if (name === "task_board_action")
-        return summarizeKeyValues(args, ["scope"]);
-    if (name === "task_board" || name === "task_board_deps" || name === "task_board_sessions")
-        return "";
-    if (name === "coding_spawn")
-        return summarizeKeyValues(args, ["runner", "workdir", "taskRef"]);
-    if (name === "coding_status")
-        return summarizeKeyValues(args, ["sessionId"]);
-    if (name === "coding_send_input")
-        return summarizeKeyValues(args, ["sessionId", "input"]);
-    if (name === "coding_kill")
-        return summarizeKeyValues(args, ["sessionId"]);
-    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"]);
-    }
-    if (name === "ado_backlog_list")
-        return summarizeKeyValues(args, ["organization", "project"]);
+    const def = findDefinition(name);
+    if (def && def.summaryKeys !== undefined) {
+        return summarizeKeyValues(args, def.summaryKeys);
+    }
     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 */
+}