@ouro.bot/cli 0.1.0-alpha.48 → 0.1.0-alpha.480

package/dist/repertoire/tools-base.js

@@ -1,750 +1,54 @@
 "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");
+exports.tools = exports.baseToolDefinitions = exports.editFileReadTracker = exports.renderInnerProgressStatus = 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 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");
+// 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; } });
+// 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");
-}
+// 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: "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) => {
-            try {
-                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 (0, thoughts_1.formatInnerDialogStatus)((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
-                }
-                const sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key);
-                const raw = fs.readFileSync(sessFile, "utf-8");
-                const data = JSON.parse(raw);
-                const messages = (data.messages || [])
-                    .filter((m) => m.role !== "system");
-                const tail = messages.slice(-count);
-                if (tail.length === 0)
-                    return "session exists but has no non-system messages.";
-                const transcript = tail.map((m) => `[${m.role}] ${m.content}`).join("\n");
-                // LLM summarization when summarize function is available
-                if (ctx?.summarize) {
-                    const trustLevel = ctx.context?.friend?.trustLevel ?? "family";
-                    const isSelfQuery = friendId === "self";
-                    const instruction = isSelfQuery
-                        ? "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning."
-                        : `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
-                    return await ctx.summarize(transcript, instruction);
-                }
-                return transcript;
-            }
-            catch {
-                return "no session found for that friend/channel/key combination.";
-            }
-        },
-    },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "send_message",
-                description: "send a message to a friend's session. the message is queued as a pending file and delivered when the target session drains its queue.",
-                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);
-            fs.mkdirSync(pendingDir, { recursive: true });
-            const fileName = `${now}-${Math.random().toString(36).slice(2, 10)}.json`;
-            const filePath = path.join(pendingDir, fileName);
-            const envelope = {
-                from: agentName,
-                friendId,
-                channel,
-                key,
-                content,
-                timestamp: now,
-            };
-            fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
-            if (isSelf) {
-                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 (0, thoughts_1.formatInnerDialogStatus)({
-                            queue: "queued to inner/dialog",
-                            wake: "inline scheduled",
-                            processing: "pending",
-                            surfaced: "nothing yet",
-                        });
-                    }
-                    else {
-                        const turnResult = await runInnerDialogTurn({ reason: "instinct" });
-                        return (0, thoughts_1.formatInnerDialogStatus)({
-                            queue: "queued to inner/dialog",
-                            wake: "inline fallback",
-                            processing: "processed",
-                            surfaced: (0, thoughts_1.formatSurfacedValue)((0, thoughts_1.extractThoughtResponseFromMessages)(turnResult?.messages ?? [])),
-                        });
-                    }
-                }
-                return (0, thoughts_1.formatInnerDialogStatus)({
-                    queue: "queued to inner/dialog",
-                    wake: "daemon requested",
-                    processing: "pending",
-                    surfaced: "nothing yet",
-                });
-            }
-            const preview = content.length > 80 ? content.slice(0, 80) + "…" : content;
-            const target = `${channel}/${key}`;
-            return `message queued for delivery to ${friendId} on ${target}. preview: "${preview}". it will be delivered when their session is next active.`;
-        },
-    },
+    ...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,
 ];
+// 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"],
-        },
-    },
-};