@ouro.bot/cli 0.1.0-alpha.216 → 0.1.0-alpha.217

package/changelog.json

@@ -1,6 +1,17 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.217",
+      "changes": [
+        "feat: Bitwarden vault client (bw CLI wrapper) with credential gateway — BitwardenClient class with SDK-first/CLI-fallback, singleton accessor, nerves events on all operations. Raw secrets never enter model context.",
+        "feat: vault tools (vault_get, vault_store, vault_list, vault_delete) with trust gating — read ops require friend+, write/delete require family-only. Destructive operations require confirmation.",
+        "feat: stealth browser MCP configuration with trust gating — Playwright MCP auto-provisions when configured, browser tools appear in agent tool list. Trust-gated to CLI and trusted 1:1 only (group chat blocked).",
+        "feat: travel API tools (weather_lookup, travel_advisory, geocode_search) — native weather via OpenWeatherMap + vault-backed API key, State Dept RSS feed for advisories, geocoding via Nominatim. All friend+ trust-gated.",
+        "feat: credential gateway (vaultKey on apiRequest()) — automatic secret injection from vault into HTTP headers at call time, keeping credentials out of model context entirely.",
+        "feat: travel-planning and browser-navigation skills"
+      ]
+    },
     {
       "version": "0.1.0-alpha.216",
       "changes": [

package/dist/heart/outlook/outlook-http.js

@@ -398,14 +398,14 @@ async function startOutlookHttpServer(options = {}) {
             writeJson(response, 404, { ok: false, error: `unknown agent surface: ${surface}` });
             return;
         }
-        /* v8 ignore start — SPA fallback for client-side routing */
+        /* v8 ignore start — SPA fallback for client-side routing @preserve */
         const spaDir = resolveSpaDistDir();
         if (spaDir) {
             if (serveStaticFile(response, path.join(spaDir, "index.html")))
                 return;
         }
-        /* v8 ignore stop */
         writeJson(response, 404, { ok: false, error: `not found: ${pathname}` });
+        /* v8 ignore stop */
     });
     await new Promise((resolve, reject) => {
         server.once("error", reject);

package/dist/repertoire/api-client.js

@@ -10,12 +10,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiRequest = apiRequest;
 const api_error_1 = require("../heart/api-error");
 const runtime_1 = require("../nerves/runtime");
+const bitwarden_client_1 = require("./bitwarden-client");
 /**
  * Execute an authenticated API request with standard logging and error handling.
  * Returns the response body as a pretty-printed JSON string.
  */
 async function apiRequest(options) {
-    const { baseUrl, method, path, token, clientName, serviceLabel, connectionName, body, extraHeaders, contentType, eventMeta, } = options;
+    const { baseUrl, method, path, token, clientName, serviceLabel, connectionName, body, extraHeaders, contentType, eventMeta, vaultKey, vaultField, } = options;
+    // Resolve token from vault if vaultKey is provided
+    let resolvedToken = token;
+    if (vaultKey) {
+        try {
+            const client = (0, bitwarden_client_1.getBitwardenClient)();
+            if (!client.isConnected()) {
+                return (0, api_error_1.handleApiError)(new Error("Vault is locked — connect the vault first"), serviceLabel, connectionName);
+            }
+            resolvedToken = await client.getRawSecret(vaultKey, vaultField ?? "apiKey");
+            (0, runtime_1.emitNervesEvent)({
+                event: "client.vault_fetch",
+                component: "clients",
+                message: `fetched credential from vault for ${serviceLabel}`,
+                meta: { client: clientName, vaultKey },
+            });
+        }
+        catch (err) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.vault_error",
+                component: "clients",
+                message: `failed to fetch vault credential for ${serviceLabel}`,
+                /* v8 ignore next -- defensive: getRawSecret throws Error instances @preserve */
+                meta: { client: clientName, vaultKey, reason: err instanceof Error ? err.message : String(err) },
+            });
+            return (0, api_error_1.handleApiError)(err, serviceLabel, connectionName);
+        }
+    }
     try {
         (0, runtime_1.emitNervesEvent)({
             event: "client.request_start",
@@ -25,7 +54,7 @@ async function apiRequest(options) {
         });
         const url = `${baseUrl}${path}`;
         const headers = {
-            Authorization: `Bearer ${token}`,
+            Authorization: `Bearer ${resolvedToken}`,
             "Content-Type": contentType ?? "application/json",
             ...extraHeaders,
         };

package/dist/repertoire/bitwarden-client.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * Bitwarden vault client for credential management.
+ *
+ * SDK-first approach: attempts dynamic import of @bitwarden/sdk-napi,
+ * falls back to `bw` CLI with --session flag.
+ *
+ * Raw secrets are NEVER returned to callers except via getRawSecret(),
+ * which is reserved for internal use by the credential gateway (apiRequest vaultKey).
+ */
+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.BitwardenClient = void 0;
+exports.getBitwardenClient = getBitwardenClient;
+exports.resetBitwardenClient = resetBitwardenClient;
+const child_process_1 = require("child_process");
+const runtime_1 = require("../nerves/runtime");
+class BitwardenClient {
+    sessionKey = null;
+    connected = false;
+    clientMode = null;
+    async connect(config) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.vault_connect_start",
+            component: "clients",
+            message: "connecting to Bitwarden vault",
+            meta: { mode: config.mode ?? "auto" },
+        });
+        try {
+            if (config.mode === "cli") {
+                await this.connectCli(config);
+            }
+            else {
+                // Try SDK first, fall back to CLI
+                try {
+                    await this.connectSdk(config);
+                }
+                catch {
+                    (0, runtime_1.emitNervesEvent)({
+                        event: "client.vault_sdk_fallback",
+                        component: "clients",
+                        message: "SDK not available, falling back to bw CLI",
+                        meta: {},
+                    });
+                    await this.connectCli(config);
+                }
+            }
+            (0, runtime_1.emitNervesEvent)({
+                event: "client.vault_connect_end",
+                component: "clients",
+                message: "connected to Bitwarden vault",
+                meta: { mode: this.clientMode },
+            });
+        }
+        catch (err) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.vault_connect_error",
+                component: "clients",
+                message: "failed to connect to Bitwarden vault",
+                /* v8 ignore next -- defensive: execCli always wraps in Error @preserve */
+                meta: { reason: err instanceof Error ? err.message : String(err) },
+            });
+            throw err;
+        }
+    }
+    async disconnect() {
+        this.sessionKey = null;
+        this.connected = false;
+        this.clientMode = null;
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.vault_disconnect",
+            component: "clients",
+            message: "disconnected from Bitwarden vault",
+            meta: {},
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async getItem(id) {
+        this.requireConnected();
+        return this.withNervesEvents("getItem", { id }, async () => {
+            const raw = await this.fetchRawItem(id);
+            return this.stripSecrets(raw);
+        });
+    }
+    async createItem(name, fields) {
+        this.requireConnected();
+        return this.withNervesEvents("createItem", { name }, async () => {
+            const itemFields = Object.entries(fields).map(([k, v]) => ({
+                name: k,
+                value: v,
+                type: 0, // text type
+            }));
+            const itemTemplate = {
+                type: 1, // login type
+                name,
+                fields: itemFields,
+                login: {},
+            };
+            const encoded = Buffer.from(JSON.stringify(itemTemplate)).toString("base64");
+            const stdout = await this.execCli(["create", "item", encoded]);
+            const parsed = this.parseCliResponse(stdout);
+            return { id: parsed.id, name: parsed.name, type: parsed.type };
+        });
+    }
+    async listItems(search) {
+        this.requireConnected();
+        return this.withNervesEvents("listItems", { search }, async () => {
+            const args = ["list", "items"];
+            if (search) {
+                args.push("--search", search);
+            }
+            const stdout = await this.execCli(args);
+            const parsed = this.parseCliResponse(stdout);
+            const items = Array.isArray(parsed.data) ? parsed.data : (Array.isArray(parsed) ? parsed : []);
+            return items.map((item) => ({ id: item.id, name: item.name, type: item.type }));
+        });
+    }
+    async deleteItem(id) {
+        this.requireConnected();
+        return this.withNervesEvents("deleteItem", { id }, async () => {
+            await this.execCli(["delete", "item", id]);
+        });
+    }
+    /**
+     * Internal: used by credential gateway (PR 5) to get raw secret for HTTP injection.
+     * NOT exposed via tools -- only called by apiRequest() internally.
+     */
+    async getRawSecret(itemId, fieldName) {
+        this.requireConnected();
+        return this.withNervesEvents("getRawSecret", { itemId, fieldName }, async () => {
+            const raw = await this.fetchRawItem(itemId);
+            // Check custom fields first
+            if (raw.fields) {
+                const field = raw.fields.find((f) => f.name === fieldName);
+                if (field)
+                    return field.value;
+            }
+            // Check login.password
+            if (fieldName === "password" && raw.login?.password) {
+                return raw.login.password;
+            }
+            throw new Error(`field "${fieldName}" not found on vault item "${itemId}"`);
+        });
+    }
+    // --- Private methods ---
+    requireConnected() {
+        if (!this.connected) {
+            throw new Error("vault not connected -- call connect() first");
+        }
+    }
+    async withNervesEvents(operation, meta, fn) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "client.request_start",
+            component: "clients",
+            message: `vault ${operation} starting`,
+            meta: { operation, ...meta },
+        });
+        try {
+            const result = await fn();
+            (0, runtime_1.emitNervesEvent)({
+                event: "client.request_end",
+                component: "clients",
+                message: `vault ${operation} complete`,
+                meta: { operation, ...meta },
+            });
+            return result;
+        }
+        catch (err) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "client.error",
+                component: "clients",
+                message: `vault ${operation} failed`,
+                /* v8 ignore next -- defensive: callers always throw Error instances @preserve */
+                meta: { operation, reason: err instanceof Error ? err.message : String(err), ...meta },
+            });
+            throw err;
+        }
+    }
+    async connectSdk(_config) {
+        // Attempt dynamic import of SDK
+        // This will throw if the package is not installed
+        const sdk = await Promise.resolve(`${"@bitwarden/sdk-napi"}`).then(s => __importStar(require(s)));
+        /* v8 ignore start -- SDK not yet published; path tested when package becomes available @preserve */
+        const client = new sdk.BitwardenClient({ apiUrl: _config.serverUrl ?? "https://api.bitwarden.com" }, 0);
+        await client.auth().loginAccessToken(_config.accessToken, "");
+        this.connected = true;
+        this.clientMode = "sdk";
+        /* v8 ignore stop */
+    }
+    async connectCli(config) {
+        this.sessionKey = config.accessToken;
+        // Verify CLI is available and session key works
+        await this.execCli(["status"]);
+        this.connected = true;
+        this.clientMode = "cli";
+    }
+    async fetchRawItem(id) {
+        const stdout = await this.execCli(["get", "item", id]);
+        const parsed = this.parseCliResponse(stdout);
+        return parsed;
+    }
+    stripSecrets(raw) {
+        const item = {
+            id: raw.id,
+            name: raw.name,
+            type: raw.type,
+        };
+        if (raw.notes)
+            item.notes = raw.notes;
+        if (raw.fields)
+            item.fields = raw.fields;
+        if (raw.login) {
+            item.login = {};
+            if (raw.login.username)
+                item.login.username = raw.login.username;
+            if (raw.login.uris)
+                item.login.uris = raw.login.uris;
+            // password intentionally NOT copied
+        }
+        return item;
+    }
+    parseCliResponse(stdout) {
+        const parsed = JSON.parse(stdout);
+        // bw CLI with --response wraps in { success, data }
+        if (parsed.success !== undefined && parsed.data !== undefined) {
+            return parsed.data;
+        }
+        return parsed;
+    }
+    execCli(args) {
+        return new Promise((resolve, reject) => {
+            const fullArgs = [...args, "--session", this.sessionKey, "--response"];
+            (0, child_process_1.execFile)("bw", fullArgs, { timeout: 30_000 }, (err, stdout, _stderr) => {
+                if (err) {
+                    reject(new Error(`bw CLI error: ${err.message}`));
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+    }
+}
+exports.BitwardenClient = BitwardenClient;
+// Singleton accessor
+let _client = null;
+function getBitwardenClient() {
+    if (!_client) {
+        _client = new BitwardenClient();
+    }
+    return _client;
+}
+function resetBitwardenClient() {
+    _client = null;
+}

package/dist/repertoire/guardrails.js

@@ -211,6 +211,26 @@ function resolveOuroSubcommand(command) {
         return tokens[0];
     return null;
 }
+// --- MCP server-specific trust rules ---
+const MCP_SERVER_TRUST = {
+    browser: { minTrust: "friend", blockGroupChat: true },
+};
+function checkMcpServerTrust(command, context) {
+    const match = command.match(/^ouro\s+mcp\s+call\s+(\S+)/);
+    if (!match)
+        return allow;
+    const serverName = match[1];
+    const rules = MCP_SERVER_TRUST[serverName];
+    if (!rules)
+        return allow; // no special rules for this server
+    if (!trustLevelSatisfied(rules.minTrust, context.trustLevel ?? "friend")) {
+        return deny(REASONS.needsTrust);
+    }
+    if (rules.blockGroupChat && context.isGroupChat) {
+        return deny("browser tools are only available in 1:1 conversations, not group chats.");
+    }
+    return allow;
+}
 function checkSingleShellCommandTrust(command, trustLevel) {
     const trimmed = command.trim();
     const tokens = trimmed.split(/\s+/);
@@ -262,8 +282,39 @@ function checkWriteTrustGuardrails(toolName, args, context) {
         return allow;
     return deny(REASONS.needsTrustForWrite);
 }
+// --- vault tool trust gating ---
+// Vault write tools: family only
+const VAULT_FAMILY_TOOLS = new Set(["vault_store", "vault_delete"]);
+// Vault read tools: friend+
+const VAULT_TRUSTED_TOOLS = new Set(["vault_get", "vault_list"]);
+// Travel tools: friend+ (weather_lookup accesses vault credentials indirectly;
+// advisory and geocode are public APIs but gated for consistency)
+const TRAVEL_TRUSTED_TOOLS = new Set(["weather_lookup", "travel_advisory", "geocode_search"]);
+function checkVaultTrustGuardrails(toolName, context) {
+    if (VAULT_FAMILY_TOOLS.has(toolName)) {
+        if (context.trustLevel === "family")
+            return allow;
+        return deny(REASONS.needsTrust);
+    }
+    if (VAULT_TRUSTED_TOOLS.has(toolName) || TRAVEL_TRUSTED_TOOLS.has(toolName)) {
+        if ((0, types_1.isTrustedLevel)(context.trustLevel))
+            return allow;
+        return deny(REASONS.needsTrust);
+    }
+    return allow;
+}
 function checkTrustLevelGuardrails(toolName, args, context) {
-    // Trusted levels (family/friend) — no trust guardrails. Undefined defaults to friend.
+    // Vault tools have their own trust rules that apply at all levels
+    const vaultResult = checkVaultTrustGuardrails(toolName, context);
+    if (!vaultResult.allowed)
+        return vaultResult;
+    // MCP server-specific trust (e.g. browser blocked in group chats) — applies at all trust levels
+    if (toolName === "shell") {
+        const mcpResult = checkMcpServerTrust(args.command || "", context);
+        if (!mcpResult.allowed)
+            return mcpResult;
+    }
+    // Trusted levels (family/friend) — no further trust guardrails. Undefined defaults to friend.
     if ((0, types_1.isTrustedLevel)(context.trustLevel))
         return allow;
     if (toolName === "shell") {

package/dist/repertoire/tools-base.js

@@ -9,6 +9,8 @@ const tools_session_1 = require("./tools-session");
 const tools_continuity_1 = require("./tools-continuity");
 const tools_config_1 = require("./tools-config");
 const tools_1 = require("./coding/tools");
+const tools_vault_1 = require("./tools-vault");
+const tools_travel_1 = require("./tools-travel");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
 Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_flow_1.ponderTool; } });
@@ -32,6 +34,8 @@ exports.baseToolDefinitions = [
     ...tools_continuity_1.continuityToolDefinitions,
     ...tools_config_1.configToolDefinitions,
     ...tools_1.codingToolDefinitions,
+    ...tools_vault_1.vaultToolDefinitions,
+    ...tools_travel_1.travelToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).
 // Used by consumers that need the OpenAI function-tool format.

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-vault.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultToolDefinitions = void 0;
+const bitwarden_client_1 = require("./bitwarden-client");
+const runtime_1 = require("../nerves/runtime");
+exports.vaultToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_get",
+                description: "Retrieve a credential from the Bitwarden vault by ID or name. Returns metadata and fields but never raw passwords.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Vault item ID (preferred)" },
+                        name: {
+                            type: "string",
+                            description: "Search by name (less precise, uses first match)",
+                        },
+                    },
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_get invoked",
+                meta: { tool: "vault_get" },
+            });
+            try {
+                const client = (0, bitwarden_client_1.getBitwardenClient)();
+                if (args.id) {
+                    const item = await client.getItem(args.id);
+                    return JSON.stringify(item, null, 2);
+                }
+                if (args.name) {
+                    const items = await client.listItems(args.name);
+                    if (items.length === 0) {
+                        return `No vault item found matching "${args.name}". Try vault_list to see available items.`;
+                    }
+                    const item = await client.getItem(items[0].id);
+                    return JSON.stringify(item, null, 2);
+                }
+                return "Please provide either an id or name to look up a vault item.";
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+                return `Vault error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["id", "name"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_store",
+                description: "Store a new credential in the Bitwarden vault. Supports login credentials, API keys, and structured fields.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Name for the credential" },
+                        username: { type: "string", description: "Username (optional)" },
+                        password: { type: "string", description: "Password (optional)" },
+                        uri: { type: "string", description: "URI/URL (optional)" },
+                        notes: { type: "string", description: "Notes (optional)" },
+                        fields: {
+                            type: "string",
+                            description: 'JSON string of custom fields, e.g. {"apiKey": "key123", "region": "us-east"}',
+                        },
+                    },
+                    required: ["name"],
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_store invoked",
+                meta: { tool: "vault_store", name: args.name },
+            });
+            try {
+                const client = (0, bitwarden_client_1.getBitwardenClient)();
+                const fields = {};
+                if (args.username)
+                    fields.username = args.username;
+                if (args.password)
+                    fields.password = args.password;
+                if (args.uri)
+                    fields.uri = args.uri;
+                if (args.notes)
+                    fields.notes = args.notes;
+                if (args.fields) {
+                    const parsed = JSON.parse(args.fields);
+                    Object.assign(fields, parsed);
+                }
+                const handle = await client.createItem(args.name, fields);
+                return JSON.stringify(handle, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+                return `Vault error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        confirmationRequired: true,
+        summaryKeys: ["name"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_list",
+                description: "List credentials in the Bitwarden vault. Returns names and IDs only, never secrets.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        search: {
+                            type: "string",
+                            description: "Optional search filter",
+                        },
+                    },
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_list invoked",
+                meta: { tool: "vault_list" },
+            });
+            try {
+                const client = (0, bitwarden_client_1.getBitwardenClient)();
+                const items = await client.listItems(args.search);
+                return JSON.stringify(items, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+                return `Vault error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["search"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_delete",
+                description: "Delete a credential from the Bitwarden vault by ID.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "ID of the vault item to delete",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+        },
+        handler: async (args) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_delete invoked",
+                meta: { tool: "vault_delete", id: args.id },
+            });
+            try {
+                const client = (0, bitwarden_client_1.getBitwardenClient)();
+                await client.deleteItem(args.id);
+                return `Vault item ${args.id} deleted successfully.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: callers throw Error instances @preserve */
+                return `Vault delete failed: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        confirmationRequired: true,
+        summaryKeys: ["id"],
+    },
+];

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

@@ -0,0 +1,224 @@
+"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.setWeatherVaultConfig = setWeatherVaultConfig;
+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 bitwarden_client_1 = require("./bitwarden-client");
+// --- OpenWeatherMap ---
+/**
+ * Vault item ID and field name for OpenWeatherMap API key.
+ * Override via setWeatherVaultConfig() for custom vault layouts.
+ */
+let weatherVaultItemId = "openweathermap-api";
+let weatherVaultField = "apiKey";
+function setWeatherVaultConfig(itemId, field) {
+    weatherVaultItemId = itemId;
+    if (field)
+        weatherVaultField = field;
+}
+async function getWeatherApiKey() {
+    const client = (0, bitwarden_client_1.getBitwardenClient)();
+    return client.getRawSecret(weatherVaultItemId, weatherVaultField);
+}
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.216",
+  "version": "0.1.0-alpha.217",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

package/skills/browser-navigation.md

@@ -0,0 +1,110 @@
+# Browser Navigation Skill
+
+When to use browser tools and how to navigate effectively.
+
+## When to Use Browser Tools
+
+Use browser navigation when:
+- The target site has no API (e.g., Airbnb, VRBO, travel blogs)
+- Content is dynamic or requires JavaScript rendering
+- Login-required pages need session-based access
+- You need to verify visual content (screenshots, layouts)
+- Price comparison requires real-time scraping
+
+Do NOT use browser tools when:
+- A dedicated API or MCP server exists (prefer `weather_lookup`, Duffel MCP, etc.)
+- The data is available via a public JSON endpoint
+- The task can be completed with `web_search`
+
+## Stealth Browsing Best Practices
+
+The `@playwright/mcp` server is configured with realistic user-agent and viewport settings. To avoid detection on travel sites:
+
+- **Add delays between navigations**: Wait 2-5 seconds between page loads. Never hammer requests in rapid succession.
+- **Vary timing**: Use random delays rather than fixed intervals (e.g., 2-5s, not exactly 3s every time).
+- **Avoid predictable patterns**: Don't navigate the same path repeatedly in short succession.
+- **Use realistic scroll behavior**: Scroll gradually through pages rather than jumping to specific elements.
+- **Respect robots.txt**: Check for rate limits and crawling restrictions.
+
+## Navigation Workflow
+
+Follow this pattern for every page interaction:
+
+1. **Navigate**: Use `browser_navigate` to load the page
+2. **Wait**: Allow the page to fully load (use `browser_wait` if needed)
+3. **Snapshot**: Take a `browser_snapshot` to understand the page structure
+4. **Extract**: Parse the accessibility tree for relevant data
+5. **Screenshot** (optional): Use `browser_screenshot` for visual confirmation
+
+## Form Filling Patterns
+
+### Login Flows
+1. Navigate to the login page
+2. Take a snapshot to identify form fields
+3. Use `browser_type` for username/password fields
+4. Use `browser_click` to submit
+5. Wait for redirect, then verify login succeeded via snapshot
+6. NEVER hardcode credentials -- use `vault_get` to retrieve login info
+
+### Search Forms (Hotels, Flights, Rentals)
+1. Navigate to the search page
+2. Snapshot to identify input fields
+3. Fill location/date fields with `browser_type`
+4. Select options with `browser_select_option` or `browser_click`
+5. Submit the search
+6. Wait for results to load (travel sites often have loading animations)
+7. Snapshot the results page to extract listings
+
+### Booking Forms
+1. **ALWAYS confirm with the user before proceeding to payment**
+2. Fill traveler information
+3. Use vault credentials for payment (via `vault_get` -- NEVER type raw card numbers)
+4. Screenshot the final review page for user confirmation
+5. Only click "Book" / "Confirm" after explicit user approval
+
+## Anti-Bot Detection Avoidance
+
+The stealth configuration handles most fingerprinting automatically. Additionally:
+
+- **Don't access detection endpoints**: Avoid URLs containing "captcha", "challenge", "verify"
+- **Handle CAPTCHAs**: If you encounter a CAPTCHA, pause and inform the user. Do not attempt automated solving.
+- **Rotate viewport sizes occasionally**: Use different viewport sizes across sessions
+- **Maintain cookies**: Use persistent `user-data-dir` to appear as a returning user
+- **Avoid headless tells**: The user-agent is set to a real browser string
+
+## Travel Site Patterns
+
+### Airbnb / VRBO
+1. Search by location + check-in/check-out dates + guests
+2. Results load dynamically -- scroll to load more listings
+3. Extract: title, price per night, total price, rating, number of reviews
+4. For detailed info, click into each listing and snapshot
+5. Compare top 3-5 options
+
+### Hotel Sites (Booking.com, Hotels.com)
+1. Search by destination + dates + guests + rooms
+2. Filter by price range, star rating, amenities
+3. Extract: name, price, location, rating, key amenities
+4. Check cancellation policies (important for travel planning)
+
+### Flight Comparison
+1. Prefer Duffel MCP for flight search (structured API data)
+2. Use browser only if Duffel doesn't cover the airline
+3. Google Flights is useful for price comparison but requires careful navigation
+
+## Error Handling
+
+- **Page timeouts**: Retry once after 5 seconds. If still failing, inform the user.
+- **CAPTCHAs**: Stop and ask the user to solve manually.
+- **Stale elements**: Re-snapshot the page and retry the interaction.
+- **Blocked/403**: The site may have detected automation. Wait 30 seconds and try with a different approach (e.g., direct URL instead of navigation).
+- **Session expired**: Re-login using stored vault credentials.
+
+## Human Confirmation Gates
+
+**ALWAYS** confirm with the user before:
+- Any booking or payment action
+- Entering personal information (name, address, phone)
+- Agreeing to terms of service
+- Subscribing to any service
+- Any action that creates a financial obligation

package/skills/travel-planning.md

@@ -0,0 +1,143 @@
+# Travel Planning Skill
+
+Compose all travel infrastructure to plan and book trips effectively.
+
+## Research Phase
+
+### Destination Research
+1. Use `geocode_search` to find candidate destinations and get coordinates
+2. Use `weather_lookup` to check climate for travel dates
+3. Use `travel_advisory` to check US State Dept safety levels (1-4):
+   - Level 1: Exercise Normal Precautions
+   - Level 2: Exercise Increased Caution
+   - Level 3: Reconsider Travel
+   - Level 4: Do Not Travel
+4. Use browser tools (see `browser-navigation` skill) for destination reviews, travel blogs, local tips
+5. Compare multiple destinations on weather, safety, cost, and flight availability
+
+### Information Gathering Workflow
+```
+geocode_search -> get coordinates
+weather_lookup -> check weather at coordinates
+travel_advisory -> check safety level
+browser tools -> reviews, local info, pricing
+```
+
+## Flight Search
+
+### Using Duffel MCP (when available)
+- Search via `ouro mcp call duffel search_flights`
+- Provide: origin, destination, dates, passengers, cabin class
+- Compare options on price, duration, stops, airline
+
+### Using Browser (fallback)
+- Use browser-navigation skill patterns for Google Flights, airline sites
+- Add delays between searches to avoid detection
+
+### Comparison Criteria
+Present top 3-5 options comparing:
+- Total price (including bags, seat selection)
+- Duration and number of stops
+- Airline and aircraft
+- Departure/arrival times
+- Cancellation/change policy
+
+## Accommodation Search
+
+### Hotel Search
+- Use Expedia MCP when available (`ouro mcp call expedia search_hotels`)
+- Compare: price per night, total stay cost, location, rating, amenities
+- Check cancellation policies (crucial for travel planning)
+
+### Vacation Rentals (Browser-based)
+- Use browser-navigation skill for Airbnb/VRBO
+- Search by location, dates, guests, budget
+- Compare: price, location proximity, reviews, amenities, host rating
+- Screenshot listings for user review
+
+### Comparison Criteria
+- Price per night and total cost
+- Location (distance to key attractions/activities)
+- Reviews and ratings
+- Amenities (WiFi, kitchen, parking, pool)
+- Cancellation flexibility
+
+## Booking Workflow
+
+### Critical Safety Gates
+- **ALWAYS confirm with user before any booking action**
+- **ALWAYS confirm before entering payment information**
+- **ALWAYS confirm before agreeing to terms**
+- **Never proceed with a financial commitment without explicit approval**
+
+### Credential Handling
+- Use `vault_get` to retrieve payment credentials (never expose raw values)
+- Use `vault_get` for loyalty program numbers
+- Use browser-navigation skill form patterns for entering credentials
+- The credential gateway ensures secrets never enter model context
+
+### Post-Booking
+- Save confirmation details (confirmation number, dates, hotel name, airline, booking reference)
+- Save to diary/journal for future reference
+- Set reminders for check-in windows
+- Note cancellation deadlines
+
+## Preference Management
+
+### Storing Preferences
+Track and reference these travel preferences:
+- Preferred airlines and alliance status
+- Preferred hotel chains and loyalty numbers
+- Seat preferences (window/aisle, extra legroom)
+- Dietary needs for in-flight meals
+- Budget ranges (per night for hotels, per flight)
+- Must-have amenities (WiFi, gym, pool)
+
+### Using Preferences
+- Reference stored preferences when searching
+- Apply airline preferences to flight comparisons
+- Apply hotel brand preferences to accommodation searches
+- Adjust budget ranges based on destination
+
+## Tool Reference
+
+### Native Tools (always available)
+- `weather_lookup` - Current weather by city or coordinates
+- `travel_advisory` - US State Dept advisory by country code
+- `geocode_search` - Location/POI search with coordinates
+- `vault_get` - Retrieve credentials (payment, loyalty)
+- `vault_store` - Store new credentials (family trust required)
+
+### MCP Tools (when configured)
+- Browser tools via `@playwright/mcp` - see `browser-navigation` skill
+- Duffel flight search (when MCP server available)
+- Expedia hotel search (when MCP server available)
+- Bitwarden vault management via `@bitwarden/mcp-server` (agent-facing interactive vault access)
+
+### Bitwarden MCP Server
+
+For agent-facing vault interaction (browsing items, searching, reading fields), configure
+`@bitwarden/mcp-server` as an MCP server in agent.json:
+
+```json
+{
+  "mcpServers": {
+    "bitwarden": {
+      "command": "npx",
+      "args": ["@bitwarden/mcp-server"]
+    }
+  }
+}
+```
+
+This is distinct from the built-in `bw` CLI-based credential gateway, which handles
+harness-internal secret injection (e.g., API keys injected into tool requests via
+`getRawSecret()`). The MCP server is for the agent to interactively browse and manage
+vault items on behalf of the user.
+
+### Human Confirmation Required For
+- Any booking or payment
+- Entering personal information
+- Agreeing to terms of service
+- Creating financial obligations
+- Sharing credentials with third parties