@ouro.bot/cli 0.1.0-alpha.49 → 0.1.0-alpha.491

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

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tripToolDefinitions = void 0;
+const types_1 = require("../mind/friends/types");
+const runtime_1 = require("../nerves/runtime");
+const store_1 = require("../trips/store");
+const core_1 = require("../trips/core");
+const identity_1 = require("../heart/identity");
+function trustAllowsTripAccess(ctx) {
+    const trustLevel = ctx?.context?.friend?.trustLevel;
+    return trustLevel === undefined || (0, types_1.isTrustedLevel)(trustLevel);
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseJsonArg(raw, label) {
+    if (typeof raw !== "string")
+        throw new Error(`${label} must be a JSON string`);
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`${label} is not valid JSON: ${error instanceof Error ? error.message : /* v8 ignore next -- JSON.parse only throws SyntaxError */ String(error)}`);
+    }
+}
+function validateTripRecord(value) {
+    if (!isRecord(value))
+        throw new Error("record must be a TripRecord object");
+    // Minimal structural validation — the agent is constructing the value but
+    // we still guard against the obvious shape mistakes that would break decrypt.
+    for (const field of ["tripId", "agentId", "ownerEmail", "name", "status", "createdAt", "updatedAt"]) {
+        if (typeof value[field] !== "string" || value[field].length === 0) {
+            throw new Error(`record.${field} must be a non-empty string`);
+        }
+    }
+    if (!Array.isArray(value.travellers))
+        throw new Error("record.travellers must be an array");
+    if (!Array.isArray(value.legs))
+        throw new Error("record.legs must be an array");
+    for (const leg of value.legs) {
+        if (!isRecord(leg))
+            throw new Error("each leg must be an object");
+        if (typeof leg.legId !== "string" || leg.legId.length === 0)
+            throw new Error("each leg requires a legId");
+        if (typeof leg.kind !== "string")
+            throw new Error("each leg requires a kind");
+        if (typeof leg.status !== "string")
+            throw new Error("each leg requires a status");
+        if (!Array.isArray(leg.evidence))
+            throw new Error(`leg ${leg.legId} requires an evidence array`);
+        for (const ev of leg.evidence) {
+            if (!isRecord(ev))
+                throw new Error(`leg ${leg.legId}: each evidence entry must be an object`);
+            if (typeof ev.messageId !== "string" || ev.messageId.length === 0)
+                throw new Error(`leg ${leg.legId}: evidence.messageId must be a non-empty string`);
+            if (typeof ev.discoveryMethod !== "string" || ev.discoveryMethod.length === 0)
+                throw new Error(`leg ${leg.legId}: evidence.discoveryMethod must be a non-empty string`);
+        }
+    }
+    return value;
+}
+function validateTripEvidence(value) {
+    if (!isRecord(value))
+        throw new Error("evidence must be a TripEvidence object");
+    for (const field of ["messageId", "reason", "recordedAt", "discoveryMethod"]) {
+        if (typeof value[field] !== "string" || value[field].length === 0) {
+            throw new Error(`evidence.${field} must be a non-empty string`);
+        }
+    }
+    return value;
+}
+function renderTripSummary(trip) {
+    const dateRange = trip.startDate && trip.endDate
+        ? `${trip.startDate} → ${trip.endDate}`
+        : trip.startDate ?? trip.endDate ?? "(no dates)";
+    const lines = [
+        `- ${trip.tripId} :: "${trip.name}" [${trip.status}; ${dateRange}; legs: ${trip.legs.length}]`,
+        `  travellers: ${trip.travellers.map((p) => p.name).join(", ") || "(none)"}`,
+    ];
+    if (trip.notes)
+        lines.push(`  notes: ${trip.notes}`);
+    return lines.join("\n");
+}
+exports.tripToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_ensure_ledger",
+                description: "Idempotently ensure this agent has a trip ledger keypair. Safe to call multiple times. Required once before any other trip_ tool.",
+                parameters: { type: "object", properties: {} },
+            },
+        },
+        handler: async (_args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            const result = (0, store_1.ensureAgentTripLedger)({ agentName: (0, identity_1.getAgentName)() });
+            const verb = result.added ? "created" : "already present";
+            return `trip ledger ${verb}: ledgerId=${result.ledger.ledgerId}, keyId=${result.ledger.keyId}, createdAt=${result.ledger.createdAt}`;
+        },
+        summaryKeys: [],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_status",
+                description: "List the agent's trip ids in sorted order. Cheap overview before opening individual trips.",
+                parameters: { type: "object", properties: {} },
+            },
+        },
+        handler: async (_args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            const tripIds = (0, store_1.listTripIds)((0, identity_1.getAgentName)());
+            if (tripIds.length === 0)
+                return "no trips on the ledger yet.";
+            return `${tripIds.length} trip(s):\n${tripIds.map((id) => `- ${id}`).join("\n")}`;
+        },
+        summaryKeys: [],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_get",
+                description: "Read one trip record by id. Returns a structured summary plus the raw JSON for further reasoning.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        tripId: { type: "string", description: "Canonical trip id (trip_<slug>_<fingerprint>)." },
+                    },
+                    required: ["tripId"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            const tripId = args.tripId;
+            if (typeof tripId !== "string" || tripId.length === 0)
+                return "tripId is required.";
+            try {
+                const trip = (0, store_1.readTripRecord)((0, identity_1.getAgentName)(), tripId);
+                return [
+                    renderTripSummary(trip),
+                    "",
+                    "raw record (JSON):",
+                    JSON.stringify(trip, null, 2),
+                ].join("\n");
+            }
+            catch (error) {
+                if (error instanceof store_1.TripNotFoundError)
+                    return error.message;
+                throw error;
+            }
+        },
+        summaryKeys: ["tripId"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_upsert",
+                description: "Create or replace a TripRecord. Pass the full record as a JSON string in `record`. Every leg requires a legId and an evidence array (each evidence entry requires messageId + discoveryMethod). Returns the persisted tripId.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        record: { type: "string", description: "Full TripRecord JSON. Must include tripId, agentId, ownerEmail, name, status, travellers[], legs[], createdAt, updatedAt." },
+                    },
+                    required: ["record"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            try {
+                const parsed = parseJsonArg(args.record, "record");
+                const trip = validateTripRecord(parsed);
+                (0, store_1.ensureAgentTripLedger)({ agentName: (0, identity_1.getAgentName)() });
+                (0, store_1.upsertTripRecord)((0, identity_1.getAgentName)(), trip);
+                return `trip upserted: ${trip.tripId} (${trip.legs.length} leg(s), status=${trip.status})`;
+            }
+            catch (error) {
+                return `upsert failed: ${error instanceof Error ? error.message : /* v8 ignore next -- non-Error throw is unreachable from validateTripRecord/parseJsonArg */ String(error)}`;
+            }
+        },
+        summaryKeys: [],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_attach_evidence",
+                description: "Append a TripEvidence record to a specific leg's evidence array. Pass tripId, legId, and the evidence as a JSON string. Useful when extracting a fact from a single mail message and attaching it to an existing leg without re-uploading the whole record.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        tripId: { type: "string", description: "Canonical trip id." },
+                        legId: { type: "string", description: "Leg id within the trip." },
+                        evidence: { type: "string", description: "TripEvidence JSON: { messageId, reason, recordedAt, discoveryMethod, excerpt? }." },
+                    },
+                    required: ["tripId", "legId", "evidence"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            const tripId = args.tripId;
+            const legId = args.legId;
+            if (typeof tripId !== "string" || tripId.length === 0)
+                return "tripId is required.";
+            if (typeof legId !== "string" || legId.length === 0)
+                return "legId is required.";
+            try {
+                const evidence = validateTripEvidence(parseJsonArg(args.evidence, "evidence"));
+                const trip = (0, store_1.readTripRecord)((0, identity_1.getAgentName)(), tripId);
+                const legIndex = trip.legs.findIndex((leg) => leg.legId === legId);
+                if (legIndex === -1)
+                    return `leg ${legId} not found in trip ${tripId}.`;
+                const leg = trip.legs[legIndex];
+                const updatedLeg = {
+                    ...leg,
+                    evidence: [...leg.evidence, evidence],
+                    updatedAt: evidence.recordedAt,
+                };
+                const updated = {
+                    ...trip,
+                    legs: [...trip.legs.slice(0, legIndex), updatedLeg, ...trip.legs.slice(legIndex + 1)],
+                    updatedAt: evidence.recordedAt,
+                };
+                (0, store_1.upsertTripRecord)((0, identity_1.getAgentName)(), updated);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "trips",
+                    event: "trips.evidence_attached",
+                    message: "trip evidence attached to leg",
+                    meta: { agentId: (0, identity_1.getAgentName)(), tripId, legId, discoveryMethod: evidence.discoveryMethod, messageId: evidence.messageId },
+                });
+                return `evidence attached to leg ${legId} in ${tripId}; leg now carries ${updatedLeg.evidence.length} evidence entries.`;
+            }
+            catch (error) {
+                if (error instanceof store_1.TripNotFoundError)
+                    return error.message;
+                return `attach failed: ${error instanceof Error ? error.message : /* v8 ignore next -- non-Error throw is unreachable from validateTripEvidence/parseJsonArg/store */ String(error)}`;
+            }
+        },
+        summaryKeys: ["tripId", "legId"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_update_leg",
+                description: "Update specific fields of an existing leg in a trip. Pass tripId, legId, and a JSON object of field updates (e.g. {status:\"cancelled\", confirmationCode:\"PNR123\"}). Existing evidence is preserved unless explicitly overwritten. Use this instead of trip_upsert when you only need to change one leg without re-emitting the whole record. The leg's `kind` cannot be changed (changing kind means a new leg).",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        tripId: { type: "string", description: "Canonical trip id." },
+                        legId: { type: "string", description: "Leg id within the trip." },
+                        updates: { type: "string", description: "JSON object of leg fields to update. Cannot include `legId` or `kind`. Common fields: status, confirmationCode, vendor, amount, checkInDate, checkOutDate, departureTime, arrivalTime, etc." },
+                        updatedAt: { type: "string", description: "ISO timestamp for the update. Used both for the leg's updatedAt and the trip's updatedAt." },
+                    },
+                    required: ["tripId", "legId", "updates", "updatedAt"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            const tripId = args.tripId;
+            const legId = args.legId;
+            const updatedAt = args.updatedAt;
+            if (typeof tripId !== "string" || tripId.length === 0)
+                return "tripId is required.";
+            if (typeof legId !== "string" || legId.length === 0)
+                return "legId is required.";
+            if (typeof updatedAt !== "string" || updatedAt.length === 0)
+                return "updatedAt is required.";
+            try {
+                const updates = parseJsonArg(args.updates, "updates");
+                if (!isRecord(updates))
+                    return "updates must be a JSON object.";
+                // Reject identity-changing fields — those would silently break referential integrity.
+                if ("legId" in updates)
+                    return "updates cannot change legId; create a new leg instead.";
+                if ("kind" in updates)
+                    return "updates cannot change kind; create a new leg instead.";
+                if (Object.keys(updates).length === 0)
+                    return "updates cannot be empty — pass at least one field.";
+                const trip = (0, store_1.readTripRecord)((0, identity_1.getAgentName)(), tripId);
+                const legIndex = trip.legs.findIndex((leg) => leg.legId === legId);
+                if (legIndex === -1)
+                    return `leg ${legId} not found in trip ${tripId}.`;
+                const leg = trip.legs[legIndex];
+                const updatedLeg = {
+                    ...leg,
+                    ...updates,
+                    legId: leg.legId,
+                    kind: leg.kind,
+                    updatedAt,
+                };
+                const updated = {
+                    ...trip,
+                    legs: [...trip.legs.slice(0, legIndex), updatedLeg, ...trip.legs.slice(legIndex + 1)],
+                    updatedAt,
+                };
+                (0, store_1.upsertTripRecord)((0, identity_1.getAgentName)(), updated);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "trips",
+                    event: "trips.leg_updated",
+                    message: "trip leg fields updated",
+                    meta: { agentId: (0, identity_1.getAgentName)(), tripId, legId, fields: Object.keys(updates) },
+                });
+                const fieldList = Object.keys(updates).join(", ");
+                return `leg ${legId} updated in ${tripId}: ${fieldList}.`;
+            }
+            catch (error) {
+                if (error instanceof store_1.TripNotFoundError)
+                    return error.message;
+                return `update failed: ${error instanceof Error ? error.message : /* v8 ignore next -- non-Error throw is unreachable from parseJsonArg/store */ String(error)}`;
+            }
+        },
+        summaryKeys: ["tripId", "legId"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_new_id",
+                description: "Compute a deterministic trip id from agentId + name + createdAt. Useful before constructing a new TripRecord so the id is stable and reproducible.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Human-friendly trip name (e.g. \"Europe summer 2026\")." },
+                        createdAt: { type: "string", description: "ISO timestamp the trip was first conceived. Pass `now` if just creating it." },
+                    },
+                    required: ["name", "createdAt"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            const name = args.name;
+            const createdAt = args.createdAt;
+            if (typeof name !== "string" || name.length === 0)
+                return "name is required.";
+            if (typeof createdAt !== "string" || createdAt.length === 0)
+                return "createdAt is required.";
+            return (0, core_1.newTripId)((0, identity_1.getAgentName)(), name, createdAt);
+        },
+        summaryKeys: ["name"],
+    },
+];

package/dist/repertoire/tools-user-profile.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userProfileToolDefinitions = void 0;
+const user_profile_1 = require("./user-profile");
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot access user profile.";
+    }
+    if (ctx.context.friend.trustLevel !== "family") {
+        return "user profile access requires family trust level.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+exports.userProfileToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_store",
+                description: "Store or update user profile fields (legal name, DOB, passport, etc.) in the agent's vault. Fields are merged with any existing profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        fields: {
+                            type: "string",
+                            description: 'JSON object with profile fields to store/update. Keys: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.',
+                        },
+                    },
+                    required: ["fields"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_store",
+                message: "user_profile_store invoked",
+                meta: { tool: "user_profile_store" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            let fields;
+            try {
+                fields = JSON.parse(args.fields);
+            }
+            catch {
+                return "invalid JSON in fields parameter.";
+            }
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                await (0, user_profile_1.updateUserProfileFields)(guard.friendId, fields, store);
+                return `profile fields stored for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: updateUserProfileFields errors are always Error instances @preserve */
+                return `failed to store profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["fields"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_get",
+                description: "Retrieve a specific field from a user's profile. Only returns the requested field, never the full profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        field: {
+                            type: "string",
+                            description: "The profile field to retrieve: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.",
+                        },
+                    },
+                    required: ["field"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_get",
+                message: "user_profile_get invoked",
+                meta: { tool: "user_profile_get", field: args.field },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const value = await (0, user_profile_1.getUserProfileField)(guard.friendId, args.field, store);
+                if (value === undefined) {
+                    return `field "${args.field}" is not set on the profile.`;
+                }
+                /* v8 ignore next -- platform-dependent v8 branch counting on ternary @preserve */
+                return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: getUserProfileField errors are always Error instances @preserve */
+                return `failed to get profile field: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["field"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_delete",
+                description: "Delete a user's entire profile from the vault. This is irreversible. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async (_args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_delete",
+                message: "user_profile_delete invoked",
+                meta: { tool: "user_profile_delete" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const deleted = await (0, user_profile_1.deleteUserProfile)(guard.friendId, store);
+                return deleted
+                    ? `profile deleted for ${guard.friendId}.`
+                    : `no profile found for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: deleteUserProfile errors are always Error instances @preserve */
+                return `failed to delete profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: [],
+    },
+];

package/dist/repertoire/tools-vault.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+exports.vaultToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_setup",
+                description: "Set up the agent's credential vault. Creates a Bitwarden account on the configured Vaultwarden server. One-time operation — idempotent if vault already exists.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async () => {
+            const agentName = (0, identity_1.getAgentName)();
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_setup invoked",
+                meta: { tool: "vault_setup", agentName },
+            });
+            return [
+                "Vault setup is human-required.",
+                "",
+                "Why I cannot do it here:",
+                "  Creating or unlocking a vault requires secret entry that must stay out of agent context.",
+                "",
+                "Do this in a terminal:",
+                `  ouro vault create --agent ${agentName}`,
+                `  ouro vault unlock --agent ${agentName}`,
+            ].join("\n");
+        },
+        summaryKeys: [],
+    },
+];