@ouro.bot/cli 0.1.0-alpha.23 → 0.1.0-alpha.230

package/dist/repertoire/tools.js

@@ -1,49 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.teamsTools = exports.finalAnswerTool = exports.tools = void 0;
+exports.surfaceToolDef = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
 exports.getToolsForChannel = getToolsForChannel;
 exports.isConfirmationRequired = isConfirmationRequired;
+exports.isConfirmationAlwaysRequired = isConfirmationAlwaysRequired;
 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 runtime_1 = require("../nerves/runtime");
+const guardrails_1 = require("./guardrails");
+const identity_1 = require("../heart/identity");
+const tools_surface_1 = require("./tools-surface");
+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; } });
-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; } });
+// 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 isRemoteChannel(capabilities) {
-    return capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
-}
-function isSharedRemoteContext(friend) {
-    const externalIds = friend.externalIds ?? [];
-    return externalIds.some((externalId) => externalId.externalId.startsWith("group:") || externalId.provider === "teams-conversation");
-}
-function isTrustedRemoteContext(context) {
-    if (!context?.friend || !isRemoteChannel(context.channel))
-        return false;
-    const trustLevel = context.friend.trustLevel ?? "stranger";
-    return trustLevel !== "stranger" && !isSharedRemoteContext(context.friend);
-}
-function shouldBlockLocalTools(capabilities, context) {
-    if (!isRemoteChannel(capabilities))
-        return false;
-    return !isTrustedRemoteContext(context);
-}
-function blockedLocalToolMessage() {
-    return "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.";
-}
-function baseToolsForCapabilities(capabilities, context) {
-    if (!shouldBlockLocalTools(capabilities, context))
-        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_surface_1.surfaceToolDefinition];
+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) {
@@ -55,34 +50,55 @@ 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) {
+    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;
+        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, ...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);
-    }
-    // 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];
+    return filterByCapability(result, providerCapabilities);
 }
 // Check whether a tool requires user confirmation before execution.
 // Reads from ToolDefinition.confirmationRequired instead of a separate Set.
@@ -90,12 +106,21 @@ function isConfirmationRequired(toolName) {
     const def = allDefinitions.find((d) => d.tool.function.name === toolName);
     return def?.confirmationRequired === true;
 }
+// Check whether a tool's confirmation is non-bypassable (cannot be skipped by skipConfirmation).
+// Used for T2 config proposals that must always require operator approval.
+function isConfirmationAlwaysRequired(toolName) {
+    const def = allDefinitions.find((d) => d.tool.function.name === toolName);
+    return def?.confirmationAlwaysRequired === true;
+}
+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);
@@ -109,16 +134,23 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    if (shouldBlockLocalTools(ctx?.context?.channel, ctx?.context) && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
-        const message = blockedLocalToolMessage();
+    // Guardrail check: structural + trust-level
+    const guardContext = {
+        readPaths: tools_base_1.editFileReadTracker,
+        trustLevel: ctx?.context?.friend?.trustLevel,
+        agentRoot: safeGetAgentRoot(),
+    };
+    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);
@@ -162,71 +194,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", "scheduledAt", "cadence"]);
-    if (name === "schedule_reminder")
-        return summarizeKeyValues(args, ["title", "scheduledAt", "cadence"]);
-    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_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 === "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 = allDefinitions.find((d) => d.tool.function.name === 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 */
+}

package/dist/repertoire/travel-api-client.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * Travel API client module.
+ *
+ * Provides HTTP clients for:
+ * - OpenWeatherMap (query-param auth via vault)
+ * - US State Dept Travel Advisories (no auth)
+ * - Nominatim Geocoding (no auth, requires User-Agent)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRAVEL_ADVISORY_RSS_URL = void 0;
+exports.getWeather = getWeather;
+exports.getWeatherByCity = getWeatherByCity;
+exports.parseAdvisoryLevel = parseAdvisoryLevel;
+exports.parseCountryName = parseCountryName;
+exports.parseAdvisoryText = parseAdvisoryText;
+exports.getTravelAdvisory = getTravelAdvisory;
+exports.geocode = geocode;
+exports.reverseGeocode = reverseGeocode;
+exports.searchPOI = searchPOI;
+const runtime_1 = require("../nerves/runtime");
+const credential_access_1 = require("./credential-access");
+// --- OpenWeatherMap ---
+/** Domain used for weather API key credential retrieval. */
+const WEATHER_CREDENTIAL_DOMAIN = "api.openweathermap.org";
+async function getWeatherApiKey() {
+    const store = (0, credential_access_1.getCredentialStore)();
+    return store.getRawSecret(WEATHER_CREDENTIAL_DOMAIN, "password");
+}
+async function getWeather(lat, lon) {
+    return withNervesEvents("getWeather", { lat, lon }, async () => {
+        const apiKey = await getWeatherApiKey();
+        const url = `https://api.openweathermap.org/data/2.5/weather?lat=${lat}&lon=${lon}&appid=${apiKey}&units=metric`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`OpenWeatherMap API error: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        return parseWeatherResponse(data);
+    });
+}
+async function getWeatherByCity(city) {
+    return withNervesEvents("getWeatherByCity", { city }, async () => {
+        const apiKey = await getWeatherApiKey();
+        const url = `https://api.openweathermap.org/data/2.5/weather?q=${encodeURIComponent(city)}&appid=${apiKey}&units=metric`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`OpenWeatherMap API error: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        return parseWeatherResponse(data);
+    });
+}
+function parseWeatherResponse(data) {
+    return {
+        temperature: data.main.temp,
+        feelsLike: data.main.feels_like,
+        description: data.weather?.[0]?.description ?? "unknown",
+        humidity: data.main.humidity,
+        windSpeed: data.wind.speed,
+        city: data.name,
+        country: data.sys.country,
+    };
+}
+// --- US State Dept Travel Advisories ---
+/**
+ * Official US State Department travel advisories RSS feed.
+ * This is the canonical public feed maintained by travel.state.gov.
+ * Returns XML/RSS with per-country advisory items.
+ */
+exports.TRAVEL_ADVISORY_RSS_URL = "https://travel.state.gov/_res/rss/TAsTWs.xml";
+/**
+ * Parse advisory level (1-4) from an RSS item title like
+ * "Afghanistan - Level 4: Do Not Travel"
+ */
+function parseAdvisoryLevel(title) {
+    const match = title.match(/Level\s+(\d)/);
+    return match ? parseInt(match[1], 10) : 0;
+}
+/**
+ * Parse country name from an RSS item title like
+ * "Afghanistan - Level 4: Do Not Travel"
+ */
+function parseCountryName(title) {
+    const dashIdx = title.indexOf(" - ");
+    return dashIdx > 0 ? title.slice(0, dashIdx).trim() : title.trim();
+}
+/**
+ * Extract advisory text from title (the part after "Level N: ").
+ */
+function parseAdvisoryText(title) {
+    const match = title.match(/Level\s+\d:\s*(.+)/);
+    return match ? match[1].trim() : title.trim();
+}
+async function getTravelAdvisory(countryCode) {
+    return withNervesEvents("getTravelAdvisory", { countryCode }, async () => {
+        const res = await fetch(exports.TRAVEL_ADVISORY_RSS_URL, {
+            headers: {
+                Accept: "application/xml, text/xml",
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`Travel advisory API error: ${res.status} ${res.statusText}`);
+        }
+        const xml = await res.text();
+        // Parse RSS items via regex (no XML parser dependency needed).
+        // Each <item> contains <title>, <pubDate>, and <category domain="Country-Tag">.
+        const itemPattern = /<item>([\s\S]*?)<\/item>/g;
+        let match;
+        while ((match = itemPattern.exec(xml)) !== null) {
+            const block = match[1];
+            // Extract country tag from <category domain="Country-Tag">XX</category>
+            const tagMatch = block.match(/<category\s+domain="Country-Tag">(.*?)<\/category>/);
+            const tag = tagMatch?.[1]?.trim().toUpperCase();
+            // The RSS feed uses FIPS country codes (e.g. "AF" for Afghanistan),
+            // which sometimes differ from ISO 3166. Try exact match first.
+            if (tag !== countryCode.toUpperCase())
+                continue;
+            const titleMatch = block.match(/<title>(.*?)<\/title>/);
+            const title = titleMatch?.[1] ?? "";
+            const pubDateMatch = block.match(/<pubDate>(.*?)<\/pubDate>/);
+            const pubDate = pubDateMatch?.[1]?.trim() ?? "";
+            return {
+                countryCode,
+                countryName: parseCountryName(title),
+                advisoryLevel: parseAdvisoryLevel(title),
+                advisoryText: parseAdvisoryText(title),
+                lastUpdated: pubDate,
+            };
+        }
+        throw new Error(`No travel advisory found for country code "${countryCode}"`);
+    });
+}
+// --- Nominatim Geocoding ---
+const NOMINATIM_BASE = "https://nominatim.openstreetmap.org";
+const NOMINATIM_HEADERS = {
+    "User-Agent": "Ouroboros/1.0 (https://github.com/ouroborosbot/ouroboros)",
+    Accept: "application/json",
+};
+async function geocode(query) {
+    return withNervesEvents("geocode", { query }, async () => {
+        const url = `${NOMINATIM_BASE}/search?q=${encodeURIComponent(query)}&format=json`;
+        const res = await fetch(url, { headers: NOMINATIM_HEADERS });
+        if (!res.ok) {
+            throw new Error(`Nominatim geocode error: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        return data.map(parseGeoLocation);
+    });
+}
+async function reverseGeocode(lat, lon) {
+    return withNervesEvents("reverseGeocode", { lat, lon }, async () => {
+        const url = `${NOMINATIM_BASE}/reverse?lat=${lat}&lon=${lon}&format=json`;
+        const res = await fetch(url, { headers: NOMINATIM_HEADERS });
+        if (!res.ok) {
+            throw new Error(`Nominatim reverse geocode error: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        return parseGeoLocation(data);
+    });
+}
+async function searchPOI(query, lat, lon, radiusKm) {
+    return withNervesEvents("searchPOI", { query, lat, lon, radiusKm }, async () => {
+        const radius = radiusKm ?? 10;
+        // Nominatim uses viewbox for bounded search (approximate degrees from km)
+        const degOffset = radius / 111; // ~111 km per degree
+        const viewbox = `${lon - degOffset},${lat + degOffset},${lon + degOffset},${lat - degOffset}`;
+        const url = `${NOMINATIM_BASE}/search?q=${encodeURIComponent(query)}&format=json&viewbox=${viewbox}&bounded=1`;
+        const res = await fetch(url, { headers: NOMINATIM_HEADERS });
+        if (!res.ok) {
+            throw new Error(`Nominatim POI search error: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        return data.map(parseGeoLocation);
+    });
+}
+function parseGeoLocation(item) {
+    return {
+        lat: parseFloat(item.lat),
+        lon: parseFloat(item.lon),
+        displayName: item.display_name,
+        type: item.type ?? "unknown",
+    };
+}
+// --- Shared nerves event wrapper ---
+async function withNervesEvents(operation, meta, fn) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "client.request_start",
+        component: "clients",
+        message: `travel API ${operation} starting`,
+        meta: { operation, ...meta },
+    });
+    try {
+        const result = await fn();
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_end",
+            component: "clients",
+            message: `travel API ${operation} complete`,
+            meta: { operation, ...meta },
+        });
+        return result;
+    }
+    catch (err) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "client.error",
+            component: "clients",
+            message: `travel API ${operation} failed`,
+            /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+            meta: { operation, reason: err instanceof Error ? err.message : String(err), ...meta },
+        });
+        throw err;
+    }
+}

package/dist/scripts/claude-code-hook.js

@@ -0,0 +1,41 @@
+"use strict";
+// Claude Code lifecycle hook handler.
+// Receives events from Claude Code's hooks system (SessionStart, Stop, PostToolUse)
+// and forwards them to the Ouroboros daemon for agent awareness.
+//
+// This module exports handleHookEvent for testability.
+// The actual hook scripts (scripts/claude-code-hook.js) read stdin and call this.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookEvent = handleHookEvent;
+const socket_client_1 = require("../heart/daemon/socket-client");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Handle a Claude Code lifecycle hook event.
+ * Sends the event to the daemon and always exits 0 (hooks must not block the IDE).
+ */
+async function handleHookEvent(hookEvent) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hook_event_received",
+        message: "claude code hook event received",
+        meta: { hookEvent: hookEvent.event, sessionId: hookEvent.sessionId },
+    });
+    try {
+        await (0, socket_client_1.sendDaemonCommand)(socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, {
+            kind: "hook.event",
+            event: hookEvent.event,
+            sessionId: hookEvent.sessionId,
+            toolName: hookEvent.toolName,
+        });
+    }
+    catch {
+        // Daemon unavailable — silently ignore. Hooks must not block.
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.hook_event_daemon_unavailable",
+            message: "daemon unavailable for hook event",
+            meta: { hookEvent: hookEvent.event },
+        });
+    }
+    return { exitCode: 0 };
+}

package/dist/scripts/claude-code-stop-hook.js

@@ -0,0 +1,47 @@
+"use strict";
+// Claude Code stop hook — checks the agent's pending queue and returns
+// any messages as additionalContext for injection into the next turn.
+//
+// This is how the agent can proactively communicate back to the dev tool user:
+// the agent surfaces a message to the pending queue, and the stop hook picks
+// it up and injects it as context in the Claude Code session.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStopHook = handleStopHook;
+const pending_1 = require("../mind/pending");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Check the pending queue for messages from the agent to this dev tool session.
+ * Returns accumulated message text as additionalContext.
+ */
+async function handleStopHook(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.stop_hook_check_start",
+        message: "checking pending queue for stop hook",
+        meta: { agentName: input.agentName, friendId: input.friendId, sessionId: input.sessionId },
+    });
+    try {
+        const pendingDir = (0, pending_1.getPendingDir)(input.agentName, input.friendId, "mcp", input.sessionId);
+        const pending = (0, pending_1.drainPending)(pendingDir);
+        if (pending.length === 0) {
+            return { additionalContext: "" };
+        }
+        const text = pending.map((m) => m.content).join("\n\n---\n\n");
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.stop_hook_check_end",
+            message: "pending messages found for stop hook",
+            meta: { agentName: input.agentName, count: pending.length },
+        });
+        return { additionalContext: text };
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.stop_hook_check_error",
+            message: "error checking pending queue in stop hook",
+            meta: { agentName: input.agentName },
+        });
+        return { additionalContext: "" };
+    }
+}