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

package/changelog.json

@@ -1,6 +1,23 @@
 {
   "_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": [
+        "fix: surface tool proactive BB delivery masked by newer MCP/CLI sessions — findFreshestFriendSession picked the single freshest session regardless of channel, so an MCP or CLI session being newer than the BB session caused the BB proactive path to be skipped entirely. Now scans all friend sessions, attempts BB delivery first on any BB session, then falls back to queuing on the freshest non-inner session."
+      ]
+    },
     {
       "version": "0.1.0-alpha.215",
       "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-surface.js

@@ -124,31 +124,28 @@ exports.surfaceToolDefinition = {
                         }
                     }
                 }
-                // Priority 2: Freshest friend session (no active threshold — proactive outreach shouldn't be gated by session age)
-                const freshest = (0, session_activity_1.findFreshestFriendSession)({
-                    sessionsDir,
-                    friendsDir,
-                    agentName,
-                    friendId,
-                });
-                if (freshest && freshest.channel !== "inner") {
-                    // Attempt proactive BB delivery
-                    if (freshest.channel === "bluebubbles") {
-                        const { sendProactiveBlueBubblesMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/bluebubbles")));
-                        const proactiveResult = await sendProactiveBlueBubblesMessageToSession({
-                            friendId: freshest.friendId,
-                            sessionKey: freshest.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, freshest.friendId, freshest.channel, `${freshest.key}.json`);
-                            appendSyntheticAssistantMessage(sessionFilePath, `[surfaced from inner dialog] ${content}`);
-                            return { status: "delivered", detail: "via iMessage" };
-                        }
+                // 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" };
                     }
-                    // Queue as pending for next interaction
+                }
+                // 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, {

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.215",
+  "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