@ouro.bot/cli 0.1.0-alpha.22 → 0.1.0-alpha.220

package/dist/repertoire/tools-shell.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellToolDefinitions = void 0;
+const child_process_1 = require("child_process");
+const shell_sessions_1 = require("./shell-sessions");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+exports.shellToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell",
+                description: "Run a shell command and return stdout/stderr. Working directory persists between calls. Use dedicated tools instead of shell when available: read_file instead of cat, edit_file instead of sed, glob instead of find, grep instead of grep/rg. Reserve shell for operations that genuinely need the shell: installing packages, running builds/tests, git operations, process management. Be careful with destructive commands -- consider reversibility before running. If a command fails, read the error output before retrying with a different approach.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        command: { type: "string" },
+                        timeout_ms: {
+                            type: "number",
+                            description: "Timeout in milliseconds. Default: 30000. Max: 600000.",
+                        },
+                        background: {
+                            type: "boolean",
+                            description: "Run in background. Returns immediately with a process ID. Use shell_status/shell_tail to monitor.",
+                        },
+                    },
+                    required: ["command"],
+                },
+            },
+        },
+        handler: (a) => {
+            // Destructive pattern detection (friction, not a block)
+            const destructivePatterns = (0, shell_sessions_1.detectDestructivePatterns)(a.command);
+            if (destructivePatterns.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    event: "tool.shell.destructive_detected",
+                    component: "tools",
+                    message: `destructive pattern detected: ${destructivePatterns.join(", ")}`,
+                    meta: { command: a.command, patterns: destructivePatterns },
+                });
+            }
+            // Background mode: spawn and return immediately
+            if (a.background === "true") {
+                const session = (0, shell_sessions_1.spawnBackgroundShell)(a.command);
+                return JSON.stringify({ id: session.id, command: session.command, status: session.status });
+            }
+            const MAX_TIMEOUT = 600000;
+            const requestedTimeout = Number(a.timeout_ms) || 0;
+            let configDefault = 30000;
+            try {
+                configDefault = (0, identity_1.loadAgentConfig)().shell?.defaultTimeout ?? 30000;
+            }
+            catch { /* test env: no --agent flag */ }
+            const baseTimeout = requestedTimeout > 0 ? requestedTimeout : configDefault;
+            const timeout = Math.min(baseTimeout, MAX_TIMEOUT);
+            const output = (0, child_process_1.execSync)(a.command, {
+                encoding: "utf-8",
+                timeout,
+            });
+            if (destructivePatterns.length > 0) {
+                return `${output}\n\n--- destructive pattern detected: ${destructivePatterns.join(", ")} ---`;
+            }
+            return output;
+        },
+        summaryKeys: ["command"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_status",
+                description: "Check status of background shell processes. Omit id to list all.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            if (!a.id) {
+                return JSON.stringify((0, shell_sessions_1.listShellSessions)());
+            }
+            const session = (0, shell_sessions_1.getShellSession)(a.id);
+            if (!session)
+                return `process not found: ${a.id}`;
+            return JSON.stringify(session);
+        },
+        summaryKeys: ["id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "shell_tail",
+                description: "Show recent output from a background shell process.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Background shell process ID" },
+                    },
+                    required: ["id"],
+                },
+            },
+        },
+        handler: (a) => {
+            /* v8 ignore next -- schema requires id, defensive guard @preserve */
+            if (!a.id)
+                return "id is required";
+            const output = (0, shell_sessions_1.tailShellSession)(a.id);
+            if (output === undefined)
+                return `process not found: ${a.id}`;
+            return output || "(no output yet)";
+        },
+        summaryKeys: ["id"],
+    },
+];

package/dist/repertoire/tools-surface.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.surfaceToolDefinition = exports.surfaceToolDef = void 0;
+const fs = __importStar(require("fs"));
+const identity_1 = require("../heart/identity");
+const surface_tool_1 = require("../senses/surface-tool");
+const obligations_1 = require("../arc/obligations");
+const session_activity_1 = require("../heart/session-activity");
+const path = __importStar(require("path"));
+// Surface tool schema — canonical home. Handler lives in senses/surface-tool.ts.
+exports.surfaceToolDef = {
+    type: "function",
+    function: {
+        name: "surface",
+        description: "share a thought outward — deliver an answer, ask a follow-up, or surface progress to whoever needs to hear it. pass delegationId to address a held thought (see your attention queue above), or friendId for spontaneous outreach. does not end your turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "the message to deliver",
+                },
+                delegationId: {
+                    type: "string",
+                    description: "ID from your attention queue — addresses a specific held thought",
+                },
+                friendId: {
+                    type: "string",
+                    description: "friend to reach out to spontaneously (when not addressing a held thought)",
+                },
+            },
+            required: ["content"],
+        },
+    },
+};
+// Surface tool handler: routes content to friend's freshest session
+/* v8 ignore start -- surface handler wiring: core logic tested via surface-tool.test.ts; this wires identity/routing deps @preserve */
+exports.surfaceToolDefinition = {
+    tool: exports.surfaceToolDef,
+    handler: async (args, ctx) => {
+        const queue = ctx?.delegatedOrigins ?? [];
+        const agentName = (() => { try {
+            return (0, identity_1.getAgentName)();
+        }
+        catch {
+            return "unknown";
+        } })();
+        const routeToFriend = async (friendId, content, queueItem) => {
+            /* v8 ignore start -- routing: integration path tested via inner-dialog routing tests @preserve */
+            try {
+                const agentRoot = (0, identity_1.getAgentRoot)();
+                const sessionsDir = path.join(agentRoot, "state", "sessions");
+                const friendsDir = path.join(agentRoot, "friends");
+                // Resolve friend name → UUID if needed (agents may pass name instead of UUID)
+                let resolvedFriendId = friendId;
+                if (!fs.existsSync(path.join(sessionsDir, friendId))) {
+                    try {
+                        const friendFiles = fs.readdirSync(friendsDir).filter((f) => f.endsWith(".json"));
+                        for (const file of friendFiles) {
+                            const raw = fs.readFileSync(path.join(friendsDir, file), "utf-8");
+                            const record = JSON.parse(raw);
+                            if (record.name?.toLowerCase() === friendId.toLowerCase() && record.id) {
+                                resolvedFriendId = record.id;
+                                break;
+                            }
+                        }
+                    }
+                    catch { /* friends dir unreadable — continue with original friendId */ }
+                }
+                friendId = resolvedFriendId;
+                // Priority 1: Bridge-preferred session (if queue item has a bridgeId)
+                if (queueItem?.bridgeId) {
+                    const { createBridgeManager } = await Promise.resolve().then(() => __importStar(require("../heart/bridges/manager")));
+                    const bridge = createBridgeManager().getBridge(queueItem.bridgeId);
+                    if (bridge && bridge.lifecycle !== "completed" && bridge.lifecycle !== "cancelled") {
+                        const allSessions = (0, session_activity_1.listSessionActivity)({ sessionsDir, friendsDir, agentName, activeThresholdMs: Number.MAX_SAFE_INTEGER });
+                        const bridgeTarget = allSessions.find((activity) => activity.friendId === friendId
+                            && activity.channel !== "inner"
+                            && bridge.attachedSessions.some((s) => s.friendId === activity.friendId && s.channel === activity.channel && s.key === activity.key));
+                        if (bridgeTarget) {
+                            // Attempt proactive BB delivery for bridge target
+                            if (bridgeTarget.channel === "bluebubbles") {
+                                const { sendProactiveBlueBubblesMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/bluebubbles")));
+                                const proactiveResult = await sendProactiveBlueBubblesMessageToSession({
+                                    friendId: bridgeTarget.friendId,
+                                    sessionKey: bridgeTarget.key,
+                                    text: content,
+                                });
+                                if (proactiveResult.delivered) {
+                                    // Inject surfaced content into the target session so it knows what was delivered
+                                    const { appendSyntheticAssistantMessage } = await Promise.resolve().then(() => __importStar(require("../mind/context")));
+                                    const sessionFilePath = path.join(sessionsDir, bridgeTarget.friendId, bridgeTarget.channel, `${bridgeTarget.key}.json`);
+                                    appendSyntheticAssistantMessage(sessionFilePath, `[surfaced from inner dialog] ${content}`);
+                                    return { status: "delivered", detail: "via iMessage" };
+                                }
+                            }
+                            // Fall back to pending queue for bridge target
+                            const { queuePendingMessage, getPendingDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
+                            const pendingDir = getPendingDir(agentName, bridgeTarget.friendId, bridgeTarget.channel, bridgeTarget.key);
+                            queuePendingMessage(pendingDir, {
+                                from: agentName,
+                                friendId: bridgeTarget.friendId,
+                                channel: bridgeTarget.channel,
+                                key: bridgeTarget.key,
+                                content,
+                                timestamp: Date.now(),
+                            });
+                            return { status: "queued", detail: `for next interaction via ${bridgeTarget.channel}` };
+                        }
+                    }
+                }
+                // Priority 2: Try proactive delivery first, then queue to freshest session
+                const allFriendSessions = (0, session_activity_1.listSessionActivity)({ sessionsDir, friendsDir, agentName, activeThresholdMs: Number.MAX_SAFE_INTEGER })
+                    .filter((s) => s.friendId === friendId && s.channel !== "inner");
+                // 2a: Attempt proactive BB delivery on any BB session (prefer freshest)
+                const bbSession = allFriendSessions.find((s) => s.channel === "bluebubbles");
+                if (bbSession) {
+                    const { sendProactiveBlueBubblesMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/bluebubbles")));
+                    const proactiveResult = await sendProactiveBlueBubblesMessageToSession({
+                        friendId: bbSession.friendId,
+                        sessionKey: bbSession.key,
+                        text: content,
+                    });
+                    if (proactiveResult.delivered) {
+                        const { appendSyntheticAssistantMessage } = await Promise.resolve().then(() => __importStar(require("../mind/context")));
+                        const sessionFilePath = path.join(sessionsDir, bbSession.friendId, bbSession.channel, `${bbSession.key}.json`);
+                        appendSyntheticAssistantMessage(sessionFilePath, `[surfaced from inner dialog] ${content}`);
+                        return { status: "delivered", detail: "via iMessage" };
+                    }
+                }
+                // 2b: No proactive delivery — queue to freshest non-inner session
+                const freshest = allFriendSessions[0];
+                if (freshest) {
+                    const { queuePendingMessage, getPendingDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
+                    const pendingDir = getPendingDir(agentName, freshest.friendId, freshest.channel, freshest.key);
+                    queuePendingMessage(pendingDir, {
+                        from: agentName,
+                        friendId: freshest.friendId,
+                        channel: freshest.channel,
+                        key: freshest.key,
+                        content,
+                        timestamp: Date.now(),
+                    });
+                    return { status: "queued", detail: `for next interaction via ${freshest.channel}` };
+                }
+                // Priority 3: Deferred — no active session found
+                const { getDeferredReturnDir } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
+                const { queuePendingMessage: queueDeferred } = await Promise.resolve().then(() => __importStar(require("../mind/pending")));
+                const deferredDir = getDeferredReturnDir(agentName, friendId);
+                queueDeferred(deferredDir, {
+                    from: agentName,
+                    friendId,
+                    channel: "deferred",
+                    key: "return",
+                    content,
+                    timestamp: Date.now(),
+                });
+                return { status: "deferred", detail: "they'll see it next time" };
+            }
+            catch {
+                return { status: "failed" };
+            }
+            /* v8 ignore stop */
+        };
+        return (0, surface_tool_1.handleSurface)({
+            content: args.content ?? "",
+            delegationId: args.delegationId,
+            friendId: args.friendId,
+            queue,
+            routeToFriend,
+            advanceObligation: (obligationId, update) => {
+                /* v8 ignore start -- obligation advance: tested via attention-queue tests @preserve */
+                try {
+                    const name = (() => { try {
+                        return (0, identity_1.getAgentName)();
+                    }
+                    catch {
+                        return "unknown";
+                    } })();
+                    (0, obligations_1.advanceReturnObligation)(name, obligationId, {
+                        status: update.status,
+                        ...(update.returnedAt !== undefined ? { returnedAt: update.returnedAt } : {}),
+                        ...(update.returnTarget !== undefined ? { returnTarget: update.returnTarget } : {}),
+                    });
+                }
+                catch {
+                    // swallowed — obligation advance must never break surface delivery
+                }
+                /* v8 ignore stop */
+            },
+            fulfillHeartObligation: (origin) => {
+                /* v8 ignore start -- heart obligation fulfillment: tested via surface-tool.test.ts @preserve */
+                try {
+                    const agentRoot = (0, identity_1.getAgentRoot)();
+                    const heartObligation = (0, obligations_1.findPendingObligationForOrigin)(agentRoot, origin);
+                    if (heartObligation) {
+                        (0, obligations_1.fulfillObligation)(agentRoot, heartObligation.id);
+                    }
+                }
+                catch {
+                    // swallowed — heart obligation fulfillment must never break surface delivery
+                }
+                /* v8 ignore stop */
+            },
+        });
+    },
+    summaryKeys: ["content", "delegationId"],
+};
+/* v8 ignore stop */

package/dist/repertoire/tools-teams.js

@@ -3,24 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.teamsToolHandlers = exports.teamsTools = exports.teamsToolDefinitions = void 0;
-exports.summarizeTeamsArgs = summarizeTeamsArgs;
+exports.teamsToolDefinitions = void 0;
 const graph_client_1 = require("./graph-client");
 const ado_client_1 = require("./ado-client");
 const graph_endpoints_json_1 = __importDefault(require("./data/graph-endpoints.json"));
 const ado_endpoints_json_1 = __importDefault(require("./data/ado-endpoints.json"));
 const runtime_1 = require("../nerves/runtime");
 const MUTATE_METHODS = ["POST", "PATCH", "DELETE"];
-// Map HTTP method to authority action name for canWrite() checks
-const METHOD_TO_ACTION = {
-    POST: "createWorkItem",
-    PATCH: "updateWorkItem",
-    DELETE: "deleteWorkItem",
-};
-// Check if a tool response indicates a 403 PERMISSION_DENIED (authority checker removed; this is now a no-op kept for call-site stability)
-function checkAndRecord403(_result, _integration, _scope, _action, _ctx) {
-    // No-op: AuthorityChecker eliminated. 403 recording removed.
-}
 const DEFAULT_ADO_QUERY = "SELECT [System.Id], [System.Title], [System.State], [System.AssignedTo] FROM WorkItems WHERE [System.AssignedTo] = @Me AND [System.State] <> 'Closed' ORDER BY [System.ChangedDate] DESC";
 exports.teamsToolDefinitions = [
     // -- Generic Graph tools --
@@ -46,6 +35,7 @@ exports.teamsToolDefinitions = [
             return (0, graph_client_1.graphRequest)(ctx.graphToken, "GET", args.path);
         },
         integration: "graph",
+        summaryKeys: ["path"],
     },
     {
         tool: {
@@ -75,6 +65,7 @@ exports.teamsToolDefinitions = [
         },
         integration: "graph",
         confirmationRequired: true,
+        summaryKeys: ["method", "path"],
     },
     // -- Generic ADO tools --
     {
@@ -101,11 +92,10 @@ exports.teamsToolDefinitions = [
                 return "AUTH_REQUIRED:ado -- I need access to Azure DevOps. Please sign in when prompted.";
             }
             const method = args.method || "GET";
-            const result = await (0, ado_client_1.adoRequest)(ctx.adoToken, method, args.organization, args.path, args.body, args.host);
-            checkAndRecord403(result, "ado", args.organization, method, ctx);
-            return result;
+            return (0, ado_client_1.adoRequest)(ctx.adoToken, method, args.organization, args.path, args.body, args.host);
         },
         integration: "ado",
+        summaryKeys: ["method", "organization", "path"],
     },
     {
         tool: {
@@ -133,14 +123,11 @@ exports.teamsToolDefinitions = [
             if (!MUTATE_METHODS.includes(args.method)) {
                 return `Invalid method "${args.method}". Must be one of: ${MUTATE_METHODS.join(", ")}`;
             }
-            /* v8 ignore next -- fallback unreachable: method is validated against MUTATE_METHODS above @preserve */
-            const action = METHOD_TO_ACTION[args.method] || args.method;
-            const result = await (0, ado_client_1.adoRequest)(ctx.adoToken, args.method, args.organization, args.path, args.body, args.host);
-            checkAndRecord403(result, "ado", args.organization, action, ctx);
-            return result;
+            return (0, ado_client_1.adoRequest)(ctx.adoToken, args.method, args.organization, args.path, args.body, args.host);
         },
         integration: "ado",
         confirmationRequired: true,
+        summaryKeys: ["method", "organization", "path"],
     },
     // -- Convenience aliases (backward compat) --
     {
@@ -159,6 +146,7 @@ exports.teamsToolDefinitions = [
             return (0, graph_client_1.getProfile)(ctx.graphToken);
         },
         integration: "graph",
+        summaryKeys: [],
     },
     {
         tool: {
@@ -202,6 +190,7 @@ exports.teamsToolDefinitions = [
             return (0, ado_client_1.queryWorkItems)(ctx.adoToken, org, query);
         },
         integration: "ado",
+        summaryKeys: ["organization", "query"],
     },
     // -- Proactive messaging --
     {
@@ -249,6 +238,7 @@ exports.teamsToolDefinitions = [
         },
         /* v8 ignore stop */
         confirmationRequired: true,
+        summaryKeys: ["user_name", "user_id"],
     },
     // -- Documentation tools --
     {
@@ -270,6 +260,7 @@ exports.teamsToolDefinitions = [
             return searchEndpoints(graph_endpoints_json_1.default, args.query || "");
         },
         integration: "graph",
+        summaryKeys: ["query"],
     },
     {
         tool: {
@@ -290,12 +281,9 @@ exports.teamsToolDefinitions = [
             return searchEndpoints(ado_endpoints_json_1.default, args.query || "");
         },
         integration: "ado",
+        summaryKeys: ["query"],
     },
 ];
-// Backward-compat: extract just the OpenAI tool schemas
-exports.teamsTools = exports.teamsToolDefinitions.map((d) => d.tool);
-// Backward-compat: extract just the handlers by name
-exports.teamsToolHandlers = Object.fromEntries(exports.teamsToolDefinitions.map((d) => [d.tool.function.name, d.handler]));
 function searchEndpoints(entries, query) {
     (0, runtime_1.emitNervesEvent)({
         component: "repertoire",
@@ -324,38 +312,3 @@ function searchEndpoints(entries, query) {
         return lines.join("\n");
     }).join("\n\n");
 }
-function summarizeTeamsArgs(name, args) {
-    function summarizeKeyValues(keys) {
-        const parts = [];
-        for (const key of keys) {
-            const raw = args[key];
-            if (raw === undefined || raw === null)
-                continue;
-            const compact = String(raw).replace(/\s+/g, " ").trim();
-            if (!compact)
-                continue;
-            const clipped = compact.length > 60 ? compact.slice(0, 60) + "..." : compact;
-            parts.push(`${key}=${clipped}`);
-        }
-        return parts.join(" ");
-    }
-    if (name === "graph_profile")
-        return "";
-    if (name === "ado_work_items")
-        return summarizeKeyValues(["organization", "query"]);
-    if (name === "graph_query")
-        return summarizeKeyValues(["path"]);
-    if (name === "graph_mutate")
-        return summarizeKeyValues(["method", "path"]);
-    if (name === "ado_query")
-        return summarizeKeyValues(["method", "organization", "path"]);
-    if (name === "ado_mutate")
-        return summarizeKeyValues(["method", "organization", "path"]);
-    if (name === "graph_docs")
-        return summarizeKeyValues(["query"]);
-    if (name === "ado_docs")
-        return summarizeKeyValues(["query"]);
-    if (name === "teams_send_message")
-        return summarizeKeyValues(["user_name", "user_id"]);
-    return undefined;
-}

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"],
+    },
+];