@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

package/dist/repertoire/tools-base.js

@@ -1,1085 +1,57 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.finalAnswerTool = exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = void 0;
-const fs = __importStar(require("fs"));
-const fg = __importStar(require("fast-glob"));
-const child_process_1 = require("child_process");
-const path = __importStar(require("path"));
-const skills_1 = require("./skills");
-const config_1 = require("../heart/config");
-const runtime_1 = require("../nerves/runtime");
-const identity_1 = require("../heart/identity");
-const socket_client_1 = require("../heart/daemon/socket-client");
-const thoughts_1 = require("../heart/daemon/thoughts");
-const manager_1 = require("../heart/bridges/manager");
-const session_recall_1 = require("../heart/session-recall");
+exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = exports.renderInnerProgressStatus = exports.speakTool = exports.restTool = exports.settleTool = exports.observeTool = exports.ponderTool = void 0;
+const tools_files_1 = require("./tools-files");
+const tools_shell_1 = require("./tools-shell");
+const tools_notes_1 = require("./tools-notes");
+const tools_bridge_1 = require("./tools-bridge");
+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 memory_1 = require("../mind/memory");
-const pending_1 = require("../mind/pending");
-const progress_story_1 = require("../heart/progress-story");
-const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
+const tools_credential_1 = require("./tools-credential");
+const tools_vault_1 = require("./tools-vault");
+const tools_travel_1 = require("./tools-travel");
+const tools_user_profile_1 = require("./tools-user-profile");
+const tools_stripe_1 = require("./tools-stripe");
+const tools_flight_1 = require("./tools-flight");
+const tools_attachments_1 = require("./tools-attachments");
+const tools_mail_1 = require("./tools-mail");
+const tools_trip_1 = require("./tools-trip");
+// 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; } });
+Object.defineProperty(exports, "observeTool", { enumerable: true, get: function () { return tools_flow_1.observeTool; } });
+Object.defineProperty(exports, "settleTool", { enumerable: true, get: function () { return tools_flow_1.settleTool; } });
+Object.defineProperty(exports, "restTool", { enumerable: true, get: function () { return tools_flow_1.restTool; } });
+Object.defineProperty(exports, "speakTool", { enumerable: true, get: function () { return tools_flow_1.speakTool; } });
+// Re-export renderInnerProgressStatus for consumers
+var tools_session_2 = require("./tools-session");
+Object.defineProperty(exports, "renderInnerProgressStatus", { enumerable: true, get: function () { return tools_session_2.renderInnerProgressStatus; } });
 // Tracks which file paths have been read via read_file in this session.
 // edit_file requires a file to be read first (must-read-first guard).
 exports.editFileReadTracker = new Set();
-function buildContextDiff(lines, changeStart, changeEnd, contextSize = 3) {
-    const start = Math.max(0, changeStart - contextSize);
-    const end = Math.min(lines.length, changeEnd + contextSize);
-    const result = [];
-    for (let i = start; i < end; i++) {
-        const lineNum = i + 1;
-        const prefix = (i >= changeStart && i < changeEnd) ? ">" : " ";
-        result.push(`${prefix} ${lineNum} | ${lines[i]}`);
-    }
-    return result.join("\n");
-}
-const NO_SESSION_FOUND_MESSAGE = "no session found for that friend/channel/key combination.";
-const EMPTY_SESSION_MESSAGE = "session exists but has no non-system messages.";
-function findDelegatingBridgeId(ctx) {
-    const currentSession = ctx?.currentSession;
-    if (!currentSession)
-        return undefined;
-    return ctx?.activeBridges?.find((bridge) => bridge.lifecycle === "active"
-        && bridge.attachedSessions.some((session) => session.friendId === currentSession.friendId
-            && session.channel === currentSession.channel
-            && session.key === currentSession.key))?.id;
-}
-async function recallSessionSafely(options) {
-    try {
-        return await (0, session_recall_1.recallSession)(options);
-    }
-    catch (error) {
-        if (options.summarize) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "daemon",
-                event: "daemon.session_recall_summary_fallback",
-                message: "session recall summarization failed; using raw transcript",
-                meta: {
-                    friendId: options.friendId,
-                    channel: options.channel,
-                    key: options.key,
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            });
-            try {
-                return await (0, session_recall_1.recallSession)({
-                    ...options,
-                    summarize: undefined,
-                });
-            }
-            catch {
-                return { kind: "missing" };
-            }
-        }
-        return { kind: "missing" };
-    }
-}
-function normalizeProgressOutcome(text) {
-    const trimmed = text.trim();
-    if (!trimmed || trimmed === "nothing yet" || trimmed === "nothing recent") {
-        return null;
-    }
-    if (trimmed.startsWith("\"") && trimmed.endsWith("\"") && trimmed.length >= 2) {
-        return trimmed.slice(1, -1);
-    }
-    return trimmed;
-}
-function writePendingEnvelope(queueDir, message) {
-    fs.mkdirSync(queueDir, { recursive: true });
-    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
-    const filePath = path.join(queueDir, fileName);
-    fs.writeFileSync(filePath, JSON.stringify(message, null, 2));
-}
-function renderCrossChatDeliveryStatus(target, result) {
-    const phase = result.status === "delivered_now"
-        ? "completed"
-        : result.status === "queued_for_later"
-            ? "queued"
-            : result.status === "blocked"
-                ? "blocked"
-                : "errored";
-    const lead = result.status === "delivered_now"
-        ? "delivered now"
-        : result.status === "queued_for_later"
-            ? "queued for later"
-            : result.status === "blocked"
-                ? "blocked"
-                : "failed";
-    return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-        scope: "shared-work",
-        phase,
-        objective: `message to ${target}`,
-        outcomeText: `${lead}\n${result.detail}`,
-    }));
-}
-function renderInnerProgressStatus(status) {
-    if (status.processing === "pending") {
-        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-            scope: "inner-delegation",
-            phase: "queued",
-            objective: status.queue,
-            outcomeText: `wake: ${status.wake}`,
-        }));
-    }
-    if (status.processing === "started") {
-        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-            scope: "inner-delegation",
-            phase: "processing",
-            outcomeText: `wake: ${status.wake}`,
-        }));
-    }
-    const completedOutcome = normalizeProgressOutcome(status.surfaced) ?? status.surfaced;
-    return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-        scope: "inner-delegation",
-        phase: "completed",
-        objective: null,
-        outcomeText: completedOutcome,
-    }));
-}
+// Combined base tool definitions — assembled from category modules.
+// Order preserved: files, shell, notes, bridge, session, continuity, config, coding.
 exports.baseToolDefinitions = [
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "read_file",
-                description: "read file contents",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        path: { type: "string" },
-                        offset: { type: "number", description: "1-based line number to start reading from" },
-                        limit: { type: "number", description: "maximum number of lines to return" },
-                    },
-                    required: ["path"],
-                },
-            },
-        },
-        handler: (a) => {
-            const content = fs.readFileSync(a.path, "utf-8");
-            exports.editFileReadTracker.add(a.path);
-            const offset = a.offset ? parseInt(a.offset, 10) : undefined;
-            const limit = a.limit ? parseInt(a.limit, 10) : undefined;
-            if (offset === undefined && limit === undefined)
-                return content;
-            const lines = content.split("\n");
-            const start = offset ? offset - 1 : 0;
-            const end = limit !== undefined ? start + limit : lines.length;
-            return lines.slice(start, end).join("\n");
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "write_file",
-                description: "write content to file",
-                parameters: {
-                    type: "object",
-                    properties: { path: { type: "string" }, content: { type: "string" } },
-                    required: ["path", "content"],
-                },
-            },
-        },
-        handler: (a) => {
-            fs.mkdirSync(path.dirname(a.path), { recursive: true });
-            fs.writeFileSync(a.path, a.content, "utf-8");
-            return "ok";
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "edit_file",
-                description: "surgically edit a file by replacing an exact string. the file must have been read via read_file first. old_string must match exactly one location in the file.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        path: { type: "string" },
-                        old_string: { type: "string" },
-                        new_string: { type: "string" },
-                    },
-                    required: ["path", "old_string", "new_string"],
-                },
-            },
-        },
-        handler: (a) => {
-            if (!exports.editFileReadTracker.has(a.path)) {
-                return `error: you must read the file with read_file before editing it. call read_file on ${a.path} first.`;
-            }
-            let content;
-            try {
-                content = fs.readFileSync(a.path, "utf-8");
-            }
-            catch (e) {
-                return `error: could not read file: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
-            }
-            // Count occurrences
-            const occurrences = [];
-            let searchFrom = 0;
-            while (true) {
-                const idx = content.indexOf(a.old_string, searchFrom);
-                if (idx === -1)
-                    break;
-                occurrences.push(idx);
-                searchFrom = idx + 1;
-            }
-            if (occurrences.length === 0) {
-                return `error: old_string not found in ${a.path}`;
-            }
-            if (occurrences.length > 1) {
-                return `error: old_string is ambiguous -- found ${occurrences.length} matches in ${a.path}. provide more context to make the match unique.`;
-            }
-            // Single unique match -- replace
-            const idx = occurrences[0];
-            const updated = content.slice(0, idx) + a.new_string + content.slice(idx + a.old_string.length);
-            fs.writeFileSync(a.path, updated, "utf-8");
-            // Build contextual diff
-            const lines = updated.split("\n");
-            const prefixLines = content.slice(0, idx).split("\n");
-            const changeStartLine = prefixLines.length - 1;
-            const newStringLines = a.new_string.split("\n");
-            const changeEndLine = changeStartLine + newStringLines.length;
-            return buildContextDiff(lines, changeStartLine, changeEndLine);
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "glob",
-                description: "find files matching a glob pattern. returns matching paths sorted alphabetically, one per line.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        pattern: { type: "string", description: "glob pattern (e.g. **/*.ts)" },
-                        cwd: { type: "string", description: "directory to search from (defaults to process.cwd())" },
-                    },
-                    required: ["pattern"],
-                },
-            },
-        },
-        handler: (a) => {
-            const cwd = a.cwd || process.cwd();
-            const matches = fg.globSync(a.pattern, { cwd, dot: true });
-            return matches.sort().join("\n");
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "grep",
-                description: "search file contents for lines matching a regex pattern. searches recursively when given a directory. returns matching lines with file path and line numbers.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        pattern: { type: "string", description: "regex pattern to search for" },
-                        path: { type: "string", description: "file or directory to search" },
-                        context_lines: { type: "number", description: "number of surrounding context lines (default 0)" },
-                        include: { type: "string", description: "glob filter to limit searched files (e.g. *.ts)" },
-                    },
-                    required: ["pattern", "path"],
-                },
-            },
-        },
-        handler: (a) => {
-            const targetPath = a.path;
-            const regex = new RegExp(a.pattern);
-            const contextLines = parseInt(a.context_lines || "0", 10);
-            const includeGlob = a.include || undefined;
-            function searchFile(filePath) {
-                let content;
-                try {
-                    content = fs.readFileSync(filePath, "utf-8");
-                }
-                catch {
-                    return [];
-                }
-                const lines = content.split("\n");
-                const matchIndices = new Set();
-                for (let i = 0; i < lines.length; i++) {
-                    if (regex.test(lines[i])) {
-                        matchIndices.add(i);
-                    }
-                }
-                if (matchIndices.size === 0)
-                    return [];
-                const outputIndices = new Set();
-                for (const idx of matchIndices) {
-                    const start = Math.max(0, idx - contextLines);
-                    const end = Math.min(lines.length - 1, idx + contextLines);
-                    for (let i = start; i <= end; i++) {
-                        outputIndices.add(i);
-                    }
-                }
-                const sortedIndices = [...outputIndices].sort((a, b) => a - b);
-                const results = [];
-                for (const idx of sortedIndices) {
-                    const lineNum = idx + 1;
-                    if (matchIndices.has(idx)) {
-                        results.push(`${filePath}:${lineNum}: ${lines[idx]}`);
-                    }
-                    else {
-                        results.push(`-${filePath}:${lineNum}: ${lines[idx]}`);
-                    }
-                }
-                return results;
-            }
-            function collectFiles(dirPath) {
-                const files = [];
-                function walk(dir) {
-                    let entries;
-                    try {
-                        entries = fs.readdirSync(dir, { withFileTypes: true });
-                    }
-                    catch {
-                        return;
-                    }
-                    for (const entry of entries) {
-                        const fullPath = path.join(dir, entry.name);
-                        if (entry.isDirectory()) {
-                            walk(fullPath);
-                        }
-                        else if (entry.isFile()) {
-                            files.push(fullPath);
-                        }
-                    }
-                }
-                walk(dirPath);
-                return files.sort();
-            }
-            function matchesGlob(filePath, glob) {
-                const escaped = glob
-                    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-                    .replace(/\*/g, ".*")
-                    .replace(/\?/g, ".");
-                return new RegExp(`(^|/)${escaped}$`).test(filePath);
-            }
-            const stat = fs.statSync(targetPath, { throwIfNoEntry: false });
-            if (!stat)
-                return "";
-            if (stat.isFile()) {
-                return searchFile(targetPath).join("\n");
-            }
-            let files = collectFiles(targetPath);
-            if (includeGlob) {
-                files = files.filter((f) => matchesGlob(f, includeGlob));
-            }
-            const allResults = [];
-            for (const file of files) {
-                allResults.push(...searchFile(file));
-            }
-            return allResults.join("\n");
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "shell",
-                description: "run shell command",
-                parameters: {
-                    type: "object",
-                    properties: { command: { type: "string" } },
-                    required: ["command"],
-                },
-            },
-        },
-        handler: (a) => (0, child_process_1.execSync)(a.command, { encoding: "utf-8", timeout: 30000 }),
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "list_skills",
-                description: "list all available skills",
-                parameters: { type: "object", properties: {} },
-            },
-        },
-        handler: () => JSON.stringify((0, skills_1.listSkills)()),
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "load_skill",
-                description: "load a skill by name, returns its content",
-                parameters: {
-                    type: "object",
-                    properties: { name: { type: "string" } },
-                    required: ["name"],
-                },
-            },
-        },
-        handler: (a) => {
-            try {
-                return (0, skills_1.loadSkill)(a.name);
-            }
-            catch (e) {
-                return `error: ${e}`;
-            }
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "claude",
-                description: "use claude code to query this codebase or get an outside perspective. useful for code review, second opinions, and asking questions about your own source.",
-                parameters: {
-                    type: "object",
-                    properties: { prompt: { type: "string" } },
-                    required: ["prompt"],
-                },
-            },
-        },
-        handler: (a) => {
-            try {
-                const result = (0, child_process_1.spawnSync)("claude", ["-p", "--no-session-persistence", "--dangerously-skip-permissions", "--add-dir", "."], {
-                    input: a.prompt,
-                    encoding: "utf-8",
-                    timeout: 60000,
-                });
-                if (result.error)
-                    return `error: ${result.error}`;
-                if (result.status !== 0)
-                    return `claude exited with code ${result.status}: ${result.stderr}`;
-                return result.stdout || "(no output)";
-            }
-            catch (e) {
-                return `error: ${e}`;
-            }
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "web_search",
-                description: "search the web using perplexity. returns ranked results with titles, urls, and snippets",
-                parameters: {
-                    type: "object",
-                    properties: { query: { type: "string" } },
-                    required: ["query"],
-                },
-            },
-        },
-        handler: async (a) => {
-            try {
-                const key = (0, config_1.getIntegrationsConfig)().perplexityApiKey;
-                if (!key)
-                    return "error: perplexityApiKey not configured in secrets.json";
-                const res = await fetch("https://api.perplexity.ai/search", {
-                    method: "POST",
-                    headers: {
-                        Authorization: `Bearer ${key}`,
-                        "Content-Type": "application/json",
-                    },
-                    body: JSON.stringify({ query: a.query, max_results: 5 }),
-                });
-                if (!res.ok)
-                    return `error: ${res.status} ${res.statusText}`;
-                const data = (await res.json());
-                if (!data.results?.length)
-                    return "no results found";
-                return data.results
-                    .map((r) => `${r.title}\n${r.url}\n${r.snippet}`)
-                    .join("\n\n");
-            }
-            catch (e) {
-                return `error: ${e}`;
-            }
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "memory_search",
-                description: "search remembered facts stored in psyche memory and return relevant matches for a query",
-                parameters: {
-                    type: "object",
-                    properties: { query: { type: "string" } },
-                    required: ["query"],
-                },
-            },
-        },
-        handler: async (a) => {
-            try {
-                const query = (a.query || "").trim();
-                if (!query)
-                    return "query is required";
-                const memoryRoot = path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-                const hits = await (0, memory_1.searchMemoryFacts)(query, (0, memory_1.readMemoryFacts)(memoryRoot));
-                return hits
-                    .map((fact) => `- ${fact.text} (source=${fact.source}, createdAt=${fact.createdAt})`)
-                    .join("\n");
-            }
-            catch (e) {
-                return `error: ${e instanceof Error ? e.message : String(e)}`;
-            }
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "memory_save",
-                description: "save a general memory fact i want to recall later. optional 'about' can tag the fact to a person/topic/context",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        text: { type: "string" },
-                        about: { type: "string" },
-                    },
-                    required: ["text"],
-                },
-            },
-        },
-        handler: async (a) => {
-            const text = (a.text || "").trim();
-            if (!text)
-                return "text is required";
-            const result = await (0, memory_1.saveMemoryFact)({
-                text,
-                source: "tool:memory_save",
-                about: typeof a.about === "string" ? a.about : undefined,
-            });
-            return `saved memory fact (added=${result.added}, skipped=${result.skipped})`;
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "get_friend_note",
-                description: "read a specific friend record by friend id. use this when i need notes/context about someone not currently active",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        friendId: { type: "string" },
-                    },
-                    required: ["friendId"],
-                },
-            },
-        },
-        handler: async (a, ctx) => {
-            const friendId = (a.friendId || "").trim();
-            if (!friendId)
-                return "friendId is required";
-            if (!ctx?.friendStore)
-                return "i can't read friend notes -- friend store not available";
-            const friend = await ctx.friendStore.get(friendId);
-            if (!friend)
-                return `friend not found: ${friendId}`;
-            return JSON.stringify(friend, null, 2);
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "save_friend_note",
-                description: "save something i learned about my friend. use type 'name' to update their display name, 'tool_preference' for how they like a specific tool to behave (key = tool category like 'ado', 'graph'), or 'note' for general knowledge (key = topic). when updating an existing value, set override to true if i'm replacing/correcting it. omit override (or set false) if i'm unsure and want to check what's already saved.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        type: { type: "string", enum: ["name", "tool_preference", "note"], description: "what kind of information to save" },
-                        key: { type: "string", description: "category key (required for tool_preference and note, e.g. 'ado', 'role')" },
-                        content: { type: "string", description: "the value to save" },
-                        override: { type: "string", enum: ["true", "false"], description: "set to 'true' to overwrite an existing value" },
-                    },
-                    required: ["type", "content"],
-                },
-            },
-        },
-        handler: async (a, ctx) => {
-            (0, runtime_1.emitNervesEvent)({
-                component: "repertoire",
-                event: "repertoire.save_friend_note",
-                message: "save friend note invoked",
-                meta: { type: a.type },
-            });
-            if (!ctx?.context) {
-                return "i can't save notes -- no friend context available";
-            }
-            if (!ctx.friendStore) {
-                return "i can't save notes -- friend store not available";
-            }
-            const friendId = ctx.context.friend?.id;
-            if (!friendId)
-                return "i can't save notes -- no friend identity available";
-            // Validate parameters
-            if (!a.content)
-                return "i need a content value to save";
-            const validTypes = ["name", "tool_preference", "note"];
-            if (!validTypes.includes(a.type))
-                return `i don't recognize type '${a.type}' -- use name, tool_preference, or note`;
-            if ((a.type === "tool_preference" || a.type === "note") && !a.key)
-                return "i need a key for tool_preference or note type";
-            try {
-                // Read fresh record from disk
-                const record = await ctx.friendStore.get(friendId);
-                if (!record)
-                    return "i can't find the friend record on disk";
-                const isOverride = a.override === "true";
-                if (a.type === "name") {
-                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
-                    await ctx.friendStore.put(friendId, updated);
-                    return `saved: name = ${a.content}`;
-                }
-                if (a.type === "tool_preference") {
-                    const existing = record.toolPreferences[a.key];
-                    if (existing && !isOverride) {
-                        return `i already have a preference for '${a.key}': "${existing}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
-                    }
-                    const updated = { ...record, toolPreferences: { ...record.toolPreferences, [a.key]: a.content }, updatedAt: new Date().toISOString() };
-                    await ctx.friendStore.put(friendId, updated);
-                    return `saved: toolPreference ${a.key} = ${a.content}`;
-                }
-                // type === "note"
-                // Redirect "name" key to name field
-                if (a.key === "name") {
-                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
-                    await ctx.friendStore.put(friendId, updated);
-                    return `updated friend's name to '${a.content}' (stored as name, not a note)`;
-                }
-                const existing = record.notes[a.key];
-                if (existing && !isOverride) {
-                    return `i already have a note for '${a.key}': "${existing.value}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
-                }
-                const updated = { ...record, notes: { ...record.notes, [a.key]: { value: a.content, savedAt: new Date().toISOString() } }, updatedAt: new Date().toISOString() };
-                await ctx.friendStore.put(friendId, updated);
-                return `saved: note ${a.key} = ${a.content}`;
-            }
-            catch (err) {
-                /* v8 ignore next -- defensive: non-Error branch for String(err) @preserve */
-                return `error saving note: ${err instanceof Error ? err.message : String(err)}`;
-            }
-        },
-    },
-    // -- cross-session awareness --
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "bridge_manage",
-                description: "create and manage shared live-work bridges across already-active sessions.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        action: {
-                            type: "string",
-                            enum: ["begin", "attach", "status", "promote_task", "complete", "cancel"],
-                        },
-                        bridgeId: { type: "string", description: "bridge id for all actions except begin" },
-                        objective: { type: "string", description: "objective for begin" },
-                        summary: { type: "string", description: "optional concise shared-work summary" },
-                        friendId: { type: "string", description: "target friend id for attach" },
-                        channel: { type: "string", description: "target channel for attach" },
-                        key: { type: "string", description: "target session key for attach (defaults to 'session')" },
-                        title: { type: "string", description: "task title override for promote_task" },
-                        category: { type: "string", description: "task category override for promote_task" },
-                        body: { type: "string", description: "task body override for promote_task" },
-                    },
-                    required: ["action"],
-                },
-            },
-        },
-        handler: async (args, ctx) => {
-            const manager = (0, manager_1.createBridgeManager)();
-            const action = (args.action || "").trim();
-            if (action === "begin") {
-                if (!ctx?.currentSession) {
-                    return "bridge_manage begin requires an active session context.";
-                }
-                const objective = (args.objective || "").trim();
-                if (!objective)
-                    return "objective is required for bridge begin.";
-                return (0, manager_1.formatBridgeStatus)(manager.beginBridge({
-                    objective,
-                    summary: (args.summary || objective).trim(),
-                    session: ctx.currentSession,
-                }));
-            }
-            const bridgeId = (args.bridgeId || "").trim();
-            if (!bridgeId) {
-                return "bridgeId is required for this bridge action.";
-            }
-            if (action === "attach") {
-                const friendId = (args.friendId || "").trim();
-                const channel = (args.channel || "").trim();
-                const key = (args.key || "session").trim();
-                if (!friendId || !channel) {
-                    return "friendId and channel are required for bridge attach.";
-                }
-                const sessionPath = (0, config_1.resolveSessionPath)(friendId, channel, key);
-                const recall = await recallSessionSafely({
-                    sessionPath,
-                    friendId,
-                    channel,
-                    key,
-                    messageCount: 20,
-                    trustLevel: ctx?.context?.friend?.trustLevel,
-                    summarize: ctx?.summarize,
-                });
-                if (recall.kind === "missing") {
-                    return NO_SESSION_FOUND_MESSAGE;
-                }
-                return (0, manager_1.formatBridgeStatus)(manager.attachSession(bridgeId, {
-                    friendId,
-                    channel,
-                    key,
-                    sessionPath,
-                    snapshot: recall.kind === "ok" ? recall.snapshot : EMPTY_SESSION_MESSAGE,
-                }));
-            }
-            if (action === "status") {
-                const bridge = manager.getBridge(bridgeId);
-                if (!bridge)
-                    return `bridge not found: ${bridgeId}`;
-                return (0, manager_1.formatBridgeStatus)(bridge);
-            }
-            if (action === "promote_task") {
-                return (0, manager_1.formatBridgeStatus)(manager.promoteBridgeToTask(bridgeId, {
-                    title: args.title,
-                    category: args.category,
-                    body: args.body,
-                }));
-            }
-            if (action === "complete") {
-                return (0, manager_1.formatBridgeStatus)(manager.completeBridge(bridgeId));
-            }
-            if (action === "cancel") {
-                return (0, manager_1.formatBridgeStatus)(manager.cancelBridge(bridgeId));
-            }
-            return `unknown bridge action: ${action}`;
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "query_session",
-                description: "read the last messages from another session. use this to check on a conversation with a friend or review your own inner dialog.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
-                        key: { type: "string", description: "session key (defaults to 'session')" },
-                        messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
-                        mode: { type: "string", enum: ["transcript", "status"], description: "transcript (default) or lightweight status for self/inner checks" },
-                    },
-                    required: ["friendId", "channel"],
-                },
-            },
-        },
-        handler: async (args, ctx) => {
-            const friendId = args.friendId;
-            const channel = args.channel;
-            const key = args.key || "session";
-            const count = parseInt(args.messageCount || "20", 10);
-            const mode = args.mode || "transcript";
-            if (mode === "status") {
-                if (friendId !== "self" || channel !== "inner") {
-                    return "status mode is only available for self/inner dialog.";
-                }
-                const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)((0, identity_1.getAgentRoot)());
-                const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
-                return renderInnerProgressStatus((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
-            }
-            const sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key);
-            const recall = await recallSessionSafely({
-                sessionPath: sessFile,
-                friendId,
-                channel,
-                key,
-                messageCount: count,
-                trustLevel: ctx?.context?.friend?.trustLevel,
-                summarize: ctx?.summarize,
-            });
-            if (recall.kind === "missing") {
-                return NO_SESSION_FOUND_MESSAGE;
-            }
-            if (recall.kind === "empty") {
-                return EMPTY_SESSION_MESSAGE;
-            }
-            return recall.summary;
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "send_message",
-                description: "send a message to a friend's session. when the request is explicitly authorized from a trusted live chat, the harness will try to deliver immediately; otherwise it reports truthful queued/block/failure state.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
-                        key: { type: "string", description: "session key (defaults to 'session')" },
-                        content: { type: "string", description: "the message content to send" },
-                    },
-                    required: ["friendId", "channel", "content"],
-                },
-            },
-        },
-        handler: async (args, ctx) => {
-            const friendId = args.friendId;
-            const channel = args.channel;
-            const key = args.key || "session";
-            const content = args.content;
-            const now = Date.now();
-            const agentName = (0, identity_1.getAgentName)();
-            // Self-routing: messages to "self" always go to inner dialog pending dir,
-            // regardless of the channel or key the agent specified.
-            const isSelf = friendId === "self";
-            const pendingDir = isSelf
-                ? (0, pending_1.getInnerDialogPendingDir)(agentName)
-                : (0, pending_1.getPendingDir)(agentName, friendId, channel, key);
-            const delegatingBridgeId = findDelegatingBridgeId(ctx);
-            const delegatedFrom = isSelf
-                && ctx?.currentSession
-                && !(ctx.currentSession.friendId === "self" && ctx.currentSession.channel === "inner")
-                ? {
-                    friendId: ctx.currentSession.friendId,
-                    channel: ctx.currentSession.channel,
-                    key: ctx.currentSession.key,
-                    ...(delegatingBridgeId ? { bridgeId: delegatingBridgeId } : {}),
-                }
-                : undefined;
-            const envelope = {
-                from: agentName,
-                friendId,
-                channel,
-                key,
-                content,
-                timestamp: now,
-                ...(delegatedFrom ? { delegatedFrom } : {}),
-            };
-            if (isSelf) {
-                writePendingEnvelope(pendingDir, envelope);
-                let wakeResponse = null;
-                try {
-                    wakeResponse = await (0, socket_client_1.requestInnerWake)(agentName);
-                }
-                catch {
-                    wakeResponse = null;
-                }
-                if (!wakeResponse?.ok) {
-                    const { runInnerDialogTurn } = await Promise.resolve().then(() => __importStar(require("../senses/inner-dialog")));
-                    if (ctx?.context?.channel.channel === "inner") {
-                        queueMicrotask(() => {
-                            void runInnerDialogTurn({ reason: "instinct" });
-                        });
-                        return renderInnerProgressStatus({
-                            queue: "queued to inner/dialog",
-                            wake: "inline scheduled",
-                            processing: "pending",
-                            surfaced: "nothing yet",
-                        });
-                    }
-                    else {
-                        const turnResult = await runInnerDialogTurn({ reason: "instinct" });
-                        const surfacedPreview = normalizeProgressOutcome((0, thoughts_1.formatSurfacedValue)((0, thoughts_1.extractThoughtResponseFromMessages)(turnResult?.messages ?? [])));
-                        return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                            scope: "inner-delegation",
-                            phase: "completed",
-                            objective: "queued to inner/dialog",
-                            outcomeText: `wake: inline fallback\n${surfacedPreview}`,
-                        }));
-                    }
-                }
-                return renderInnerProgressStatus({
-                    queue: "queued to inner/dialog",
-                    wake: "daemon requested",
-                    processing: "pending",
-                    surfaced: "nothing yet",
-                });
-            }
-            const deliveryResult = await (0, cross_chat_delivery_1.deliverCrossChatMessage)({
-                friendId,
-                channel,
-                key,
-                content,
-                intent: ctx?.currentSession && ctx.currentSession.friendId !== "self"
-                    ? "explicit_cross_chat"
-                    : "generic_outreach",
-                ...(ctx?.currentSession && ctx.currentSession.friendId !== "self"
-                    ? {
-                        authorizingSession: {
-                            friendId: ctx.currentSession.friendId,
-                            channel: ctx.currentSession.channel,
-                            key: ctx.currentSession.key,
-                            trustLevel: ctx?.context?.friend?.trustLevel,
-                        },
-                    }
-                    : {}),
-            }, {
-                agentName,
-                queuePending: (message) => writePendingEnvelope(pendingDir, message),
-                deliverers: {
-                    bluebubbles: async (request) => {
-                        const { sendProactiveBlueBubblesMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/bluebubbles")));
-                        const result = await sendProactiveBlueBubblesMessageToSession({
-                            friendId: request.friendId,
-                            sessionKey: request.key,
-                            text: request.content,
-                            intent: request.intent,
-                            authorizingSession: request.authorizingSession,
-                        });
-                        if (result.delivered) {
-                            return {
-                                status: "delivered_now",
-                                detail: "sent to the active bluebubbles chat now",
-                            };
-                        }
-                        if (result.reason === "missing_target") {
-                            return {
-                                status: "blocked",
-                                detail: "bluebubbles could not resolve a routable target for that session",
-                            };
-                        }
-                        if (result.reason === "send_error") {
-                            return {
-                                status: "failed",
-                                detail: "bluebubbles send failed",
-                            };
-                        }
-                        return {
-                            status: "unavailable",
-                            detail: "live delivery unavailable right now; queued for the next active turn",
-                        };
-                    },
-                    teams: async (request) => {
-                        if (!ctx?.botApi) {
-                            return {
-                                status: "unavailable",
-                                detail: "live delivery unavailable right now; queued for the next active turn",
-                            };
-                        }
-                        const { sendProactiveTeamsMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/teams")));
-                        const result = await sendProactiveTeamsMessageToSession({
-                            friendId: request.friendId,
-                            sessionKey: request.key,
-                            text: request.content,
-                            intent: request.intent,
-                            authorizingSession: request.authorizingSession,
-                        }, {
-                            botApi: ctx.botApi,
-                        });
-                        if (result.delivered) {
-                            return {
-                                status: "delivered_now",
-                                detail: "sent to the active teams chat now",
-                            };
-                        }
-                        if (result.reason === "missing_target") {
-                            return {
-                                status: "blocked",
-                                detail: "teams could not resolve a routable target for that session",
-                            };
-                        }
-                        if (result.reason === "send_error") {
-                            return {
-                                status: "failed",
-                                detail: "teams send failed",
-                            };
-                        }
-                        return {
-                            status: "unavailable",
-                            detail: "live delivery unavailable right now; queued for the next active turn",
-                        };
-                    },
-                },
-            });
-            return renderCrossChatDeliveryStatus(`${friendId} on ${channel}/${key}`, deliveryResult);
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "set_reasoning_effort",
-                description: "adjust your own reasoning depth for subsequent turns. use higher effort for complex analysis, lower for simple tasks.",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        level: { type: "string", description: "the reasoning effort level to set" },
-                    },
-                    required: ["level"],
-                },
-            },
-        },
-        handler: (args, ctx) => {
-            if (!ctx?.supportedReasoningEfforts || !ctx.setReasoningEffort) {
-                return "reasoning effort adjustment is not available in this context.";
-            }
-            const level = (args.level || "").trim();
-            if (!ctx.supportedReasoningEfforts.includes(level)) {
-                return `invalid reasoning effort level "${level}". accepted levels: ${ctx.supportedReasoningEfforts.join(", ")}`;
-            }
-            ctx.setReasoningEffort(level);
-            (0, runtime_1.emitNervesEvent)({
-                component: "repertoire",
-                event: "repertoire.reasoning_effort_changed",
-                message: `reasoning effort set to ${level}`,
-                meta: { level },
-            });
-            return `reasoning effort set to "${level}".`;
-        },
-        requiredCapability: "reasoning-effort",
-    },
+    ...tools_files_1.fileToolDefinitions,
+    ...tools_shell_1.shellToolDefinitions,
+    ...tools_notes_1.notesToolDefinitions,
+    ...tools_bridge_1.bridgeToolDefinitions,
+    ...tools_session_1.sessionToolDefinitions,
+    ...tools_continuity_1.continuityToolDefinitions,
+    ...tools_config_1.configToolDefinitions,
     ...tools_1.codingToolDefinitions,
+    ...tools_credential_1.credentialToolDefinitions,
+    ...tools_vault_1.vaultToolDefinitions,
+    ...tools_travel_1.travelToolDefinitions,
+    ...tools_user_profile_1.userProfileToolDefinitions,
+    ...tools_stripe_1.stripeToolDefinitions,
+    ...tools_flight_1.flightToolDefinitions,
+    ...tools_attachments_1.attachmentToolDefinitions,
+    ...tools_mail_1.mailToolDefinitions,
+    ...tools_trip_1.tripToolDefinitions,
 ];
+// Convenience array of just the tool schemas (no handler/integration metadata).
+// Used by consumers that need the OpenAI function-tool format.
 exports.tools = exports.baseToolDefinitions.map((d) => d.tool);
-exports.finalAnswerTool = {
-    type: "function",
-    function: {
-        name: "final_answer",
-        description: "respond to the user with your message. call this tool when you are ready to deliver your response.",
-        parameters: {
-            type: "object",
-            properties: {
-                answer: { type: "string" },
-                intent: { type: "string", enum: ["complete", "blocked", "direct_reply"] },
-            },
-            required: ["answer"],
-        },
-    },
-};