life-pulse 1.0.0

package/dist/tools.js

@@ -0,0 +1,1037 @@
+/**
+ * Tool definitions for the life-pulse agent.
+ * Each tool is a focused query the agent can call to investigate specific areas.
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+import { openDb, safeQuery } from './db.js';
+import { resolveName, buildContactMap } from './contacts.js';
+import { getUserName } from './profile.js';
+import dayjs from 'dayjs';
+const APPLE_EPOCH = 978307200;
+const CHROME_EPOCH = 11644473600;
+const home = homedir();
+// ─── Helpers ─────────────────────────────────────────────────────
+function daysAgoApple(days) {
+    return dayjs().subtract(days, 'day').unix() - APPLE_EPOCH;
+}
+function daysAgoUnix(days) {
+    return dayjs().subtract(days, 'day').unix();
+}
+function appleToHuman(appleTs) {
+    return dayjs.unix(appleTs + APPLE_EPOCH).format('ddd MMM D h:mm A');
+}
+function limit(arr, n) { return arr.slice(0, n); }
+/** Filter out iMessage tapback reactions — "Loved", "Liked", "Laughed at", "Emphasized", "Disliked", "Questioned" */
+const TAPBACK_RE = /^(Loved|Liked|Laughed at|Disliked|Emphasized|Questioned) (".*"|".*"|an? .+)$/;
+function isReaction(text) {
+    if (!text)
+        return true;
+    return TAPBACK_RE.test(text.trim());
+}
+// ─── Tools ───────────────────────────────────────────────────────
+export const TOOLS = [
+    // 1. Overview scan
+    {
+        name: 'scan_sources',
+        description: 'Quick scan of all available data sources. Returns what data exists and rough counts. Call this FIRST to understand what you have to work with.',
+        parameters: { type: 'object', properties: {}, required: [] },
+        async execute() {
+            const results = {};
+            // iMessage
+            const msgDb = openDb(join(home, 'Library/Messages/chat.db'));
+            if (msgDb) {
+                const dayAgoNano = (BigInt(daysAgoUnix(1) - APPLE_EPOCH) * BigInt(1e9)).toString();
+                const weekAgoNano = (BigInt(daysAgoUnix(7) - APPLE_EPOCH) * BigInt(1e9)).toString();
+                const last24h = safeQuery(msgDb, 'SELECT COUNT(*) as c FROM message WHERE date > ?', [dayAgoNano]);
+                const last7d = safeQuery(msgDb, 'SELECT COUNT(*) as c FROM message WHERE date > ?', [weekAgoNano]);
+                results.iMessage = { available: true, last24h: last24h[0]?.c, last7d: last7d[0]?.c };
+                msgDb.close();
+            }
+            // Calls
+            const callDb = openDb(join(home, 'Library/Application Support/CallHistoryDB/CallHistory.storedata'));
+            if (callDb) {
+                const missed = safeQuery(callDb, `SELECT COUNT(*) as c FROM ZCALLRECORD WHERE ZCALLTYPE = 3 AND ZDATE > ?`, [daysAgoApple(7)]);
+                results.calls = { available: true, missedLast7d: missed[0]?.c };
+                callDb.close();
+            }
+            // Screen time
+            const stDb = openDb(join(home, 'Library/Application Support/Knowledge/knowledgeC.db'));
+            if (stDb) {
+                results.screenTime = { available: true };
+                stDb.close();
+            }
+            // Safari
+            const safDb = openDb(join(home, 'Library/Safari/History.db'));
+            if (safDb) {
+                const cnt = safeQuery(safDb, `SELECT COUNT(*) as c FROM history_visits WHERE visit_time > ?`, [daysAgoApple(7)]);
+                results.safari = { available: true, visitsLast7d: cnt[0]?.c };
+                safDb.close();
+            }
+            // Mail
+            for (const v of ['V10', 'V9', 'V8']) {
+                const p = join(home, `Library/Mail/${v}/MailData/Envelope Index`);
+                if (existsSync(p)) {
+                    const db = openDb(p);
+                    if (db) {
+                        const unread = safeQuery(db, 'SELECT COUNT(*) as c FROM messages WHERE read = 0');
+                        const flagged = safeQuery(db, 'SELECT COUNT(*) as c FROM messages WHERE flagged = 1');
+                        results.mail = { available: true, unread: unread[0]?.c, flagged: flagged[0]?.c };
+                        db.close();
+                    }
+                    break;
+                }
+            }
+            // Calendar
+            const calDb = join(home, 'Library/Calendars/Calendar.sqlitedb');
+            results.calendar = { available: existsSync(calDb) };
+            // Git projects
+            try {
+                const projects = readdirSync(join(home, 'Projects')).filter(f => {
+                    try {
+                        return existsSync(join(home, 'Projects', f, '.git'));
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                results.gitProjects = { available: true, repos: projects };
+            }
+            catch {
+                results.gitProjects = { available: false };
+            }
+            // ChatGPT history
+            const chatgptPaths = [
+                join(home, 'Library/Application Support/com.openai.chat'),
+                join(home, 'Library/Group Containers/group.com.openai.chat'),
+            ];
+            for (const p of chatgptPaths) {
+                if (existsSync(p)) {
+                    results.chatgpt = { available: true, path: p };
+                    break;
+                }
+            }
+            if (!results.chatgpt)
+                results.chatgpt = { available: false };
+            // Claude CLI history
+            const claudeDir = join(home, '.claude');
+            results.claudeCLI = { available: existsSync(claudeDir) };
+            // Notes
+            const notesDb = join(home, 'Library/Containers/com.apple.Notes/Data/Library/Notes/NotesV7.storedata');
+            results.notes = { available: existsSync(notesDb) };
+            results.timestamp = dayjs().format('YYYY-MM-DD HH:mm:ss');
+            return JSON.stringify(results, null, 1);
+        }
+    },
+    // 2. iMessage queries
+    {
+        name: 'get_messages',
+        description: 'Search iMessage conversations. Can filter by contact name, time range, or keyword. Returns messages with sender names resolved.',
+        parameters: {
+            type: 'object',
+            properties: {
+                contact: { type: 'string', description: 'Filter by contact name (partial match). Leave empty for all.' },
+                days: { type: 'number', description: 'How many days back to look. Default 1.' },
+                keyword: { type: 'string', description: 'Search for keyword in message text.' },
+                limit: { type: 'number', description: 'Max messages to return. Default 50.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const db = openDb(join(home, 'Library/Messages/chat.db'));
+            if (!db)
+                return JSON.stringify({ error: 'iMessage DB not available' });
+            const days = params.days || 1;
+            const maxResults = params.limit || 50;
+            const contactFilter = params.contact;
+            const keyword = params.keyword;
+            const handles = safeQuery(db, 'SELECT ROWID, id FROM handle');
+            const handleMap = new Map(handles.map(h => [h.ROWID, h.id]));
+            const agoNano = (BigInt(daysAgoUnix(days) - APPLE_EPOCH) * BigInt(1e9)).toString();
+            let sql = `SELECT text, date, is_from_me, handle_id FROM message WHERE date > ?`;
+            const sqlParams = [agoNano];
+            if (keyword) {
+                sql += ` AND text LIKE ?`;
+                sqlParams.push(`%${keyword}%`);
+            }
+            sql += ` ORDER BY date DESC LIMIT ${maxResults * 3}`;
+            const msgs = safeQuery(db, sql, sqlParams);
+            const results = [];
+            for (const m of msgs) {
+                if (!m.text || isReaction(m.text))
+                    continue;
+                const handle = handleMap.get(m.handle_id) || '';
+                const name = resolveName(handle);
+                if (contactFilter && !name.toLowerCase().includes(contactFilter.toLowerCase()))
+                    continue;
+                const dateSeconds = Number(BigInt(m.date) / BigInt(1e9)) + APPLE_EPOCH;
+                results.push({
+                    from: m.is_from_me ? getUserName() : name,
+                    text: m.text.slice(0, 200),
+                    when: dayjs.unix(dateSeconds).format('ddd MMM D h:mm A'),
+                    direction: m.is_from_me ? 'sent' : 'received',
+                });
+                if (results.length >= maxResults)
+                    break;
+            }
+            db.close();
+            return JSON.stringify({ count: results.length, messages: results }, null, 1);
+        }
+    },
+    // 3. Unanswered messages
+    {
+        name: 'get_unanswered_messages',
+        description: 'Find messages from other people that the user has NOT replied to. These are conversations where the last message is from someone else.',
+        parameters: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'How many days back. Default 3.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const db = openDb(join(home, 'Library/Messages/chat.db'));
+            if (!db)
+                return JSON.stringify({ error: 'not available' });
+            const days = params.days || 3;
+            const handles = safeQuery(db, 'SELECT ROWID, id FROM handle');
+            const handleMap = new Map(handles.map(h => [h.ROWID, h.id]));
+            const agoNano = (BigInt(daysAgoUnix(days) - APPLE_EPOCH) * BigInt(1e9)).toString();
+            const msgs = safeQuery(db, `SELECT text, date, is_from_me, handle_id FROM message WHERE date > ? ORDER BY date DESC`, [agoNano]);
+            // Group by handle, find where last msg is from them
+            const lastByHandle = new Map();
+            for (const m of msgs) {
+                if (!lastByHandle.has(m.handle_id))
+                    lastByHandle.set(m.handle_id, m);
+            }
+            const unanswered = [];
+            for (const [handleId, m] of lastByHandle) {
+                if (m.is_from_me || !m.text || isReaction(m.text))
+                    continue;
+                const handle = handleMap.get(handleId) || '';
+                const name = resolveName(handle);
+                if (name === 'Unknown' || name === 'unknown')
+                    continue;
+                const dateSeconds = Number(BigInt(m.date) / BigInt(1e9)) + APPLE_EPOCH;
+                unanswered.push({
+                    from: name,
+                    text: m.text.slice(0, 150),
+                    when: dayjs.unix(dateSeconds).format('ddd MMM D h:mm A'),
+                });
+            }
+            unanswered.sort((a, b) => dayjs(b.when, 'ddd MMM D h:mm A').unix() - dayjs(a.when, 'ddd MMM D h:mm A').unix());
+            db.close();
+            return JSON.stringify({ unanswered: unanswered.slice(0, 20) }, null, 1);
+        }
+    },
+    // 4. Call history
+    {
+        name: 'get_calls',
+        description: 'Get recent call history. Shows missed, incoming, and outgoing calls with names.',
+        parameters: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'Days back. Default 7.' },
+                missed_only: { type: 'boolean', description: 'Only show missed calls not returned.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const db = openDb(join(home, 'Library/Application Support/CallHistoryDB/CallHistory.storedata'));
+            if (!db)
+                return JSON.stringify({ error: 'not available' });
+            const days = params.days || 7;
+            const calls = safeQuery(db, `SELECT ZADDRESS as address, ZDURATION as duration, ZDATE as date, ZCALLTYPE as call_type
+             FROM ZCALLRECORD WHERE ZDATE > ? ORDER BY ZDATE DESC`, [daysAgoApple(days)]);
+            const missed = calls.filter(c => c.call_type === 3);
+            const outgoing = calls.filter(c => c.call_type === 2);
+            if (params.missed_only) {
+                const missedNotReturned = missed
+                    .filter(m => !outgoing.some(o => o.address === m.address))
+                    .map(m => ({ name: resolveName(m.address), when: appleToHuman(m.date) }));
+                db.close();
+                return JSON.stringify({ missedNotReturned }, null, 1);
+            }
+            const recent = calls.slice(0, 30).map(c => ({
+                name: resolveName(c.address),
+                type: c.call_type === 1 ? 'incoming' : c.call_type === 2 ? 'outgoing' : 'missed',
+                duration: `${Math.round(c.duration / 60)}min`,
+                when: appleToHuman(c.date),
+            }));
+            db.close();
+            return JSON.stringify({ total: calls.length, recent }, null, 1);
+        }
+    },
+    // 5. Screen time
+    {
+        name: 'get_screen_time',
+        description: 'Get app usage / screen time data. Shows which apps were used and for how long.',
+        parameters: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'Days back. Default 1.' },
+                app: { type: 'string', description: 'Filter by app name (partial match).' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const db = openDb(join(home, 'Library/Application Support/Knowledge/knowledgeC.db'));
+            if (!db)
+                return JSON.stringify({ error: 'not available' });
+            const days = params.days || 1;
+            const appFilter = params.app;
+            let sql = `SELECT ZVALUESTRING as app, (ZENDDATE - ZSTARTDATE) as duration,
+                        datetime(ZSTARTDATE + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as start_time
+                 FROM ZOBJECT WHERE ZSTREAMNAME = '/app/usage'
+                   AND ZSTARTDATE > ? AND ZVALUESTRING IS NOT NULL`;
+            const sqlParams = [daysAgoApple(days)];
+            if (appFilter) {
+                sql += ` AND ZVALUESTRING LIKE ?`;
+                sqlParams.push(`%${appFilter}%`);
+            }
+            sql += ` ORDER BY ZSTARTDATE DESC`;
+            const usage = safeQuery(db, sql, sqlParams);
+            const appTotals = new Map();
+            const hourly = new Array(24).fill(0);
+            for (const row of usage) {
+                if (!row.app || row.duration <= 0 || row.duration > 86400)
+                    continue;
+                appTotals.set(row.app, (appTotals.get(row.app) || 0) + row.duration);
+                if (row.start_time) {
+                    const hour = parseInt(row.start_time.split(' ')[1]?.split(':')[0] || '0');
+                    hourly[hour] += row.duration;
+                }
+            }
+            const ranked = [...appTotals.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20)
+                .map(([bundle, secs]) => ({
+                app: bundle.replace(/^com\./, '').replace(/\./g, ' '),
+                bundle,
+                hours: +(secs / 3600).toFixed(1),
+            }));
+            const lateNight = [23, 0, 1, 2, 3, 4].reduce((s, h) => s + hourly[h], 0) / 3600;
+            const peakHour = hourly.indexOf(Math.max(...hourly));
+            db.close();
+            return JSON.stringify({ totalHours: +(ranked.reduce((s, r) => s + r.hours, 0)).toFixed(1), topApps: ranked, lateNightHours: +lateNight.toFixed(1), peakHour }, null, 1);
+        }
+    },
+    // 6. Browser history + searches
+    {
+        name: 'get_browsing',
+        description: 'Get Safari/Chrome browsing history, search queries, and top domains.',
+        parameters: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'Days back. Default 3.' },
+                searches_only: { type: 'boolean', description: 'Only return search queries.' },
+                domain: { type: 'string', description: 'Filter by domain.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const days = params.days || 3;
+            const results = {};
+            // Safari
+            const safDb = openDb(join(home, 'Library/Safari/History.db'));
+            if (safDb) {
+                const history = safeQuery(safDb, `SELECT hi.url, hv.title, datetime(hv.visit_time + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as visited
+           FROM history_visits hv JOIN history_items hi ON hv.history_item = hi.id
+           WHERE hv.visit_time > ? ORDER BY hv.visit_time DESC LIMIT 2000`, [daysAgoApple(days)]);
+                // Searches
+                const searches = [];
+                const seen = new Set();
+                for (const row of history) {
+                    try {
+                        const u = new URL(row.url);
+                        const q = u.searchParams.get('q') || u.searchParams.get('query') || u.searchParams.get('search_query');
+                        if (q) {
+                            const k = q.toLowerCase();
+                            if (!seen.has(k)) {
+                                seen.add(k);
+                                searches.push({ query: q, when: row.visited });
+                            }
+                        }
+                    }
+                    catch { }
+                }
+                if (params.searches_only) {
+                    safDb.close();
+                    return JSON.stringify({ searches: searches.slice(0, 50) }, null, 1);
+                }
+                // Domains
+                const domains = new Map();
+                for (const r of history) {
+                    try {
+                        let d = new URL(r.url).hostname.replace('www.', '');
+                        if (params.domain && !d.includes(params.domain))
+                            continue;
+                        domains.set(d, (domains.get(d) || 0) + 1);
+                    }
+                    catch { }
+                }
+                // Interesting pages
+                const pages = history.filter(h => h.title && h.title.length > 10 && !h.title.startsWith('Google'))
+                    .slice(0, 20).map(h => ({ title: h.title, domain: new URL(h.url).hostname, when: h.visited }));
+                results.safari = {
+                    totalVisits: history.length,
+                    topDomains: [...domains.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20).map(([d, c]) => ({ domain: d, visits: c })),
+                    searches: searches.slice(0, 30),
+                    recentPages: pages,
+                };
+                safDb.close();
+            }
+            // Chrome
+            const chromeBase = join(home, 'Library/Application Support/Google/Chrome');
+            for (const profile of ['Default', 'Profile 1']) {
+                const p = join(chromeBase, profile, 'History');
+                if (existsSync(p)) {
+                    const db = openDb(p);
+                    if (db) {
+                        const agoChrome = (daysAgoUnix(days) + CHROME_EPOCH) * 1e6;
+                        const history = safeQuery(db, `SELECT title, url FROM urls WHERE last_visit_time > ? ORDER BY last_visit_time DESC LIMIT 500`, [agoChrome]);
+                        const domains = new Map();
+                        for (const r of history) {
+                            try {
+                                const d = new URL(r.url).hostname.replace('www.', '');
+                                domains.set(d, (domains.get(d) || 0) + 1);
+                            }
+                            catch { }
+                        }
+                        results.chrome = {
+                            totalVisits: history.length,
+                            topDomains: [...domains.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15).map(([d, c]) => ({ domain: d, visits: c })),
+                        };
+                        db.close();
+                    }
+                    break;
+                }
+            }
+            return JSON.stringify(results, null, 1);
+        }
+    },
+    // 7. Email
+    {
+        name: 'get_email_summary',
+        description: 'Get email summary — unread count, flagged, top senders.',
+        parameters: { type: 'object', properties: {}, required: [] },
+        async execute() {
+            for (const v of ['V10', 'V9', 'V8']) {
+                const p = join(home, `Library/Mail/${v}/MailData/Envelope Index`);
+                if (!existsSync(p))
+                    continue;
+                const db = openDb(p);
+                if (!db)
+                    continue;
+                const unread = safeQuery(db, 'SELECT COUNT(*) as c FROM messages WHERE read = 0');
+                const flagged = safeQuery(db, 'SELECT COUNT(*) as c FROM messages WHERE flagged = 1');
+                const topSenders = safeQuery(db, `SELECT a.address as sender, COUNT(*) as cnt FROM messages m
+           JOIN addresses a ON m.sender = a.ROWID
+           WHERE m.read = 0 GROUP BY a.address ORDER BY cnt DESC LIMIT 15`);
+                db.close();
+                return JSON.stringify({
+                    unread: unread[0]?.c, flagged: flagged[0]?.c,
+                    topUnreadSenders: topSenders.map(s => ({ sender: s.sender, count: s.cnt })),
+                }, null, 1);
+            }
+            return JSON.stringify({ error: 'Mail DB not found' });
+        }
+    },
+    // 8. Git activity
+    {
+        name: 'get_git_activity',
+        description: 'Get recent git commits across all projects in ~/Projects. Shows what code work has been happening.',
+        parameters: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'Days back. Default 7.' },
+                repo: { type: 'string', description: 'Filter to specific repo name.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const days = params.days || 7;
+            const repoFilter = params.repo;
+            const projectsDir = join(home, 'Projects');
+            if (!existsSync(projectsDir))
+                return JSON.stringify({ error: 'No ~/Projects dir' });
+            const repos = readdirSync(projectsDir).filter(f => {
+                if (repoFilter && f !== repoFilter)
+                    return false;
+                try {
+                    return existsSync(join(projectsDir, f, '.git'));
+                }
+                catch {
+                    return false;
+                }
+            });
+            const allCommits = [];
+            for (const repo of repos) {
+                try {
+                    const log = execSync(`git -C "${join(projectsDir, repo)}" log --since="${days} days ago" --pretty=format:"%s|||%ai|||%an" --no-merges 2>/dev/null`, { encoding: 'utf-8', timeout: 5000 }).trim();
+                    if (!log)
+                        continue;
+                    for (const line of log.split('\n')) {
+                        const [message, date, author] = line.split('|||');
+                        if (message)
+                            allCommits.push({ repo, message, date, author });
+                    }
+                }
+                catch { }
+            }
+            // Group by repo
+            const byRepo = new Map();
+            for (const c of allCommits) {
+                const list = byRepo.get(c.repo) || [];
+                list.push({ message: c.message, date: c.date });
+                byRepo.set(c.repo, list);
+            }
+            const summary = [...byRepo.entries()].map(([repo, commits]) => ({
+                repo, commitCount: commits.length, recentCommits: commits.slice(0, 5),
+            }));
+            return JSON.stringify({ totalCommits: allCommits.length, repos: summary }, null, 1);
+        }
+    },
+    // 9. Recent files
+    {
+        name: 'get_recent_files',
+        description: 'List recent files in Downloads and Desktop folders.',
+        parameters: {
+            type: 'object',
+            properties: {
+                folder: { type: 'string', description: 'Which folder: "downloads", "desktop", or "both". Default "both".' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const folder = params.folder || 'both';
+            const results = {};
+            const scan = (dir) => {
+                try {
+                    const files = execSync(`ls -t "${dir}" | head -20`, { encoding: 'utf-8', timeout: 5000 }).trim().split('\n').filter(Boolean);
+                    return files.map(f => {
+                        try {
+                            const stat = statSync(join(dir, f));
+                            return { name: f, age: `${dayjs().diff(dayjs(stat.mtime), 'day')}d`, size: `${(stat.size / 1024).toFixed(0)}KB` };
+                        }
+                        catch {
+                            return { name: f };
+                        }
+                    });
+                }
+                catch {
+                    return [];
+                }
+            };
+            if (folder !== 'desktop')
+                results.downloads = scan(join(home, 'Downloads'));
+            if (folder !== 'downloads')
+                results.desktop = scan(join(home, 'Desktop'));
+            return JSON.stringify(results, null, 1);
+        }
+    },
+    // 10. Shell history
+    {
+        name: 'get_shell_history',
+        description: 'Get recent shell/terminal commands. Shows what the user has been doing in the terminal.',
+        parameters: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Number of recent commands. Default 50.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const maxResults = params.limit || 50;
+            const zshPath = join(home, '.zsh_history');
+            const bashPath = join(home, '.bash_history');
+            const histPath = existsSync(zshPath) ? zshPath : existsSync(bashPath) ? bashPath : null;
+            if (!histPath)
+                return JSON.stringify({ error: 'No shell history found' });
+            const raw = readFileSync(histPath, 'utf-8');
+            const lines = raw.split('\n').filter(Boolean);
+            const commands = [];
+            for (const line of lines.slice(-maxResults * 2)) {
+                const match = line.match(/^: (\d+):\d+;(.*)/);
+                if (match) {
+                    commands.push({ cmd: match[2], when: dayjs.unix(parseInt(match[1])).format('MMM D h:mm A') });
+                }
+                else if (!line.startsWith(':')) {
+                    commands.push({ cmd: line });
+                }
+            }
+            return JSON.stringify({ recentCommands: commands.slice(-maxResults) }, null, 1);
+        }
+    },
+    // 11. Notes
+    {
+        name: 'get_notes',
+        description: 'Get recent Apple Notes titles and modification dates.',
+        parameters: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max notes. Default 20.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const maxResults = params.limit || 20;
+            const db = openDb(join(home, 'Library/Containers/com.apple.Notes/Data/Library/Notes/NotesV7.storedata'));
+            if (!db)
+                return JSON.stringify({ error: 'Notes DB not available' });
+            let notes = safeQuery(db, `SELECT ZTITLE2 as title, datetime(ZMODIFICATIONDATE1 + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as modified
+         FROM ZICNOTEDATA WHERE ZTITLE2 IS NOT NULL ORDER BY ZMODIFICATIONDATE1 DESC LIMIT ?`, [maxResults]);
+            if (notes.length === 0) {
+                notes = safeQuery(db, `SELECT ZTITLE as title, datetime(ZMODIFICATIONDATE1 + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as modified
+           FROM ZICNOTEDATA WHERE ZTITLE IS NOT NULL ORDER BY ZMODIFICATIONDATE1 DESC LIMIT ?`, [maxResults]);
+            }
+            db.close();
+            return JSON.stringify({ notes: notes.map(n => ({ title: n.title, modified: n.modified })) }, null, 1);
+        }
+    },
+    // 12. Claude CLI history
+    {
+        name: 'get_claude_history',
+        description: 'Read recent Claude Code CLI conversation topics. Shows what the user has been working on with Claude.',
+        parameters: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'Days back. Default 3.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const days = params.days || 3;
+            const claudeDir = join(home, '.claude');
+            if (!existsSync(claudeDir))
+                return JSON.stringify({ error: 'No Claude CLI history' });
+            const projects = join(claudeDir, 'projects');
+            if (!existsSync(projects))
+                return JSON.stringify({ error: 'No projects dir' });
+            const cutoff = dayjs().subtract(days, 'day');
+            const conversations = [];
+            try {
+                const projectDirs = readdirSync(projects);
+                for (const pd of projectDirs) {
+                    const pdPath = join(projects, pd);
+                    try {
+                        const files = readdirSync(pdPath).filter(f => f.endsWith('.jsonl'));
+                        for (const f of files) {
+                            const fPath = join(pdPath, f);
+                            try {
+                                const stat = statSync(fPath);
+                                if (dayjs(stat.mtime).isBefore(cutoff))
+                                    continue;
+                                // Read first user message
+                                const content = readFileSync(fPath, 'utf-8');
+                                const firstLine = content.split('\n').find(l => l.includes('"role":"user"'));
+                                if (firstLine) {
+                                    try {
+                                        const parsed = JSON.parse(firstLine);
+                                        const msg = typeof parsed.message?.content === 'string'
+                                            ? parsed.message.content.slice(0, 100)
+                                            : Array.isArray(parsed.message?.content)
+                                                ? (parsed.message.content.find((c) => c.type === 'text')?.text || '').slice(0, 100)
+                                                : '';
+                                        if (msg) {
+                                            conversations.push({
+                                                project: pd.replace(/-/g, '/'),
+                                                firstMessage: msg,
+                                                date: dayjs(stat.mtime).format('MMM D h:mm A'),
+                                            });
+                                        }
+                                    }
+                                    catch { }
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+            conversations.sort((a, b) => dayjs(b.date, 'MMM D h:mm A').unix() - dayjs(a.date, 'MMM D h:mm A').unix());
+            return JSON.stringify({ conversations: conversations.slice(0, 15) }, null, 1);
+        }
+    },
+    // 13. Contact lookup
+    {
+        name: 'lookup_contact',
+        description: 'Look up a contact by name or phone/email to get their full info.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Name, phone number, or email to search for.' },
+            },
+            required: ['query']
+        },
+        async execute(params) {
+            const query = params.query.toLowerCase();
+            const map = buildContactMap();
+            const matches = [];
+            for (const [handle, name] of map) {
+                if (name.toLowerCase().includes(query) || handle.toLowerCase().includes(query)) {
+                    matches.push({ handle, name });
+                }
+            }
+            // Dedupe by name
+            const seen = new Set();
+            const unique = matches.filter(m => { if (seen.has(m.name))
+                return false; seen.add(m.name); return true; });
+            return JSON.stringify({ results: unique.slice(0, 10) }, null, 1);
+        }
+    },
+    // 14. Broad message search across ALL conversations
+    {
+        name: 'search_all_messages',
+        description: 'Search ALL iMessage conversations for a keyword or phrase. Use this to chase down context — if someone mentions "Thursday", search for "thursday", "thurs", "thur" to find ALL related discussions across ALL contacts. Returns matching messages with who said them and when.',
+        parameters: {
+            type: 'object',
+            properties: {
+                keywords: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of keywords to search for. Will search for each independently. E.g. ["thursday", "thurs", "li po", "fireworks"]'
+                },
+                days: { type: 'number', description: 'Days back. Default 7.' },
+                limit: { type: 'number', description: 'Max results per keyword. Default 20.' },
+            },
+            required: ['keywords']
+        },
+        async execute(params) {
+            const db = openDb(join(home, 'Library/Messages/chat.db'));
+            if (!db)
+                return JSON.stringify({ error: 'not available' });
+            const keywords = params.keywords;
+            const days = params.days || 7;
+            const maxPer = params.limit || 20;
+            const handles = safeQuery(db, 'SELECT ROWID, id FROM handle');
+            const handleMap = new Map(handles.map(h => [h.ROWID, h.id]));
+            const agoNano = (BigInt(daysAgoUnix(days) - APPLE_EPOCH) * BigInt(1e9)).toString();
+            const results = {};
+            for (const kw of keywords) {
+                const msgs = safeQuery(db, `SELECT text, date, is_from_me, handle_id FROM message
+           WHERE date > ? AND text LIKE ? ORDER BY date DESC LIMIT ?`, [agoNano, `%${kw}%`, maxPer * 2]);
+                results[kw] = msgs
+                    .filter(m => m.text && !isReaction(m.text))
+                    .slice(0, maxPer)
+                    .map(m => {
+                    const handle = handleMap.get(m.handle_id) || '';
+                    const dateSeconds = Number(BigInt(m.date) / BigInt(1e9)) + APPLE_EPOCH;
+                    return {
+                        from: m.is_from_me ? getUserName() : resolveName(handle),
+                        text: m.text.slice(0, 200),
+                        when: dayjs.unix(dateSeconds).format('ddd MMM D h:mm A'),
+                    };
+                });
+            }
+            db.close();
+            return JSON.stringify(results, null, 1);
+        }
+    },
+    // 15. Deep relationship profile
+    {
+        name: 'profile_contact',
+        description: 'Build a deep relationship profile for a contact. Returns: how long you\'ve known them, message frequency over time, call frequency, recent topics, relationship tier, shared group chats, and whether the user has searched for them online. Use this to assess how important a commitment is and how flexible the relationship is.',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Contact name to profile.' },
+            },
+            required: ['name']
+        },
+        async execute(params) {
+            const contactName = params.name.toLowerCase();
+            const profile = { name: params.name };
+            // --- iMessage history ---
+            const msgDb = openDb(join(home, 'Library/Messages/chat.db'));
+            if (msgDb) {
+                const handles = safeQuery(msgDb, 'SELECT ROWID, id FROM handle');
+                const matchingHandles = handles.filter(h => resolveName(h.id).toLowerCase().includes(contactName));
+                if (matchingHandles.length > 0) {
+                    const handleIds = matchingHandles.map(h => h.ROWID);
+                    const placeholders = handleIds.map(() => '?').join(',');
+                    // Total messages ever
+                    const total = safeQuery(msgDb, `SELECT COUNT(*) as c FROM message WHERE handle_id IN (${placeholders})`, handleIds);
+                    // Messages by time period
+                    const day1Nano = (BigInt(daysAgoUnix(1) - APPLE_EPOCH) * BigInt(1e9)).toString();
+                    const day7Nano = (BigInt(daysAgoUnix(7) - APPLE_EPOCH) * BigInt(1e9)).toString();
+                    const day30Nano = (BigInt(daysAgoUnix(30) - APPLE_EPOCH) * BigInt(1e9)).toString();
+                    const day90Nano = (BigInt(daysAgoUnix(90) - APPLE_EPOCH) * BigInt(1e9)).toString();
+                    const last24h = safeQuery(msgDb, `SELECT COUNT(*) as c FROM message WHERE handle_id IN (${placeholders}) AND date > ?`, [...handleIds, day1Nano]);
+                    const last7d = safeQuery(msgDb, `SELECT COUNT(*) as c FROM message WHERE handle_id IN (${placeholders}) AND date > ?`, [...handleIds, day7Nano]);
+                    const last30d = safeQuery(msgDb, `SELECT COUNT(*) as c FROM message WHERE handle_id IN (${placeholders}) AND date > ?`, [...handleIds, day30Nano]);
+                    const last90d = safeQuery(msgDb, `SELECT COUNT(*) as c FROM message WHERE handle_id IN (${placeholders}) AND date > ?`, [...handleIds, day90Nano]);
+                    // First ever message (how long you've known them)
+                    const firstMsg = safeQuery(msgDb, `SELECT date FROM message WHERE handle_id IN (${placeholders}) ORDER BY date ASC LIMIT 1`, handleIds);
+                    let firstContact = 'unknown';
+                    if (firstMsg.length > 0) {
+                        const firstDateSec = Number(BigInt(firstMsg[0].date) / BigInt(1e9)) + APPLE_EPOCH;
+                        firstContact = dayjs.unix(firstDateSec).format('MMMM YYYY');
+                    }
+                    // Recent messages for topic extraction
+                    const recentMsgs = safeQuery(msgDb, `SELECT text, is_from_me, date FROM message
+             WHERE handle_id IN (${placeholders}) AND text IS NOT NULL AND text != ''
+             ORDER BY date DESC LIMIT 10`, handleIds);
+                    const recentTopics = recentMsgs.filter(m => m.text && m.text.length > 5 && !isReaction(m.text)).map(m => {
+                        const dateSec = Number(BigInt(m.date) / BigInt(1e9)) + APPLE_EPOCH;
+                        return {
+                            from: m.is_from_me ? getUserName() : params.name,
+                            text: m.text.slice(0, 120),
+                            when: dayjs.unix(dateSec).format('ddd MMM D h:mm A'),
+                        };
+                    });
+                    // Sent vs received ratio
+                    const sentCount = safeQuery(msgDb, `SELECT COUNT(*) as c FROM message WHERE handle_id IN (${placeholders}) AND is_from_me = 1`, handleIds);
+                    const recvCount = safeQuery(msgDb, `SELECT COUNT(*) as c FROM message WHERE handle_id IN (${placeholders}) AND is_from_me = 0`, handleIds);
+                    // Shared group chats
+                    const groups = safeQuery(msgDb, `SELECT DISTINCT c.display_name FROM chat c
+             JOIN chat_handle_join chj ON c.ROWID = chj.chat_id
+             WHERE chj.handle_id IN (${placeholders})
+               AND c.display_name IS NOT NULL AND c.display_name != ''`, handleIds);
+                    // Determine relationship tier
+                    const totalMsgs = total[0]?.c || 0;
+                    const last30 = last30d[0]?.c || 0;
+                    let tier = 'acquaintance';
+                    if (last30 > 100)
+                        tier = 'inner circle';
+                    else if (last30 > 30)
+                        tier = 'close friend';
+                    else if (last30 > 10)
+                        tier = 'regular contact';
+                    else if (totalMsgs > 50)
+                        tier = 'occasional contact';
+                    // Message frequency assessment
+                    let frequency = 'rarely';
+                    if (last24h[0]?.c > 5)
+                        frequency = 'multiple times daily';
+                    else if (last7d[0]?.c > 20)
+                        frequency = 'daily';
+                    else if (last30d[0]?.c > 15)
+                        frequency = 'weekly';
+                    else if (last90d[0]?.c > 10)
+                        frequency = 'monthly';
+                    profile.messaging = {
+                        totalMessagesEver: totalMsgs,
+                        last24h: last24h[0]?.c || 0,
+                        last7d: last7d[0]?.c || 0,
+                        last30d: last30d[0]?.c || 0,
+                        last90d: last90d[0]?.c || 0,
+                        sentByUser: sentCount[0]?.c || 0,
+                        receivedFromThem: recvCount[0]?.c || 0,
+                        firstContact,
+                        frequency,
+                        tier,
+                        sharedGroups: groups.map(g => g.display_name),
+                        recentTopics,
+                    };
+                }
+                msgDb.close();
+            }
+            // --- Call history ---
+            const callDb = openDb(join(home, 'Library/Application Support/CallHistoryDB/CallHistory.storedata'));
+            if (callDb) {
+                const allCalls = safeQuery(callDb, `SELECT ZADDRESS as address, ZDURATION as duration, ZDATE as date, ZCALLTYPE as call_type FROM ZCALLRECORD ORDER BY ZDATE DESC`);
+                const matchingCalls = allCalls.filter(c => {
+                    const name = resolveName(c.address);
+                    return name.toLowerCase().includes(contactName);
+                });
+                if (matchingCalls.length > 0) {
+                    const totalMinutes = Math.round(matchingCalls.reduce((s, c) => s + (c.duration || 0), 0) / 60);
+                    const lastCall = matchingCalls[0];
+                    profile.calls = {
+                        totalCalls: matchingCalls.length,
+                        totalMinutes,
+                        lastCall: lastCall ? appleToHuman(lastCall.date) : null,
+                        lastCallType: lastCall?.call_type === 1 ? 'incoming' : lastCall?.call_type === 2 ? 'outgoing' : 'missed',
+                        incoming: matchingCalls.filter(c => c.call_type === 1).length,
+                        outgoing: matchingCalls.filter(c => c.call_type === 2).length,
+                        missed: matchingCalls.filter(c => c.call_type === 3).length,
+                    };
+                }
+                callDb.close();
+            }
+            // --- Browsing: has user searched for this person? ---
+            const safDb = openDb(join(home, 'Library/Safari/History.db'));
+            if (safDb) {
+                const nameWords = contactName.split(' ').filter(w => w.length > 2);
+                const searchedFor = [];
+                for (const word of nameWords) {
+                    const hits = safeQuery(safDb, `SELECT hi.url, hv.title FROM history_visits hv
+             JOIN history_items hi ON hv.history_item = hi.id
+             WHERE hi.url LIKE ? OR hv.title LIKE ?
+             ORDER BY hv.visit_time DESC LIMIT 5`, [`%${word}%`, `%${word}%`]);
+                    for (const h of hits) {
+                        if (h.title && h.title.toLowerCase().includes(contactName)) {
+                            searchedFor.push(`${h.title} (${new URL(h.url).hostname})`);
+                        }
+                        else if (h.url.toLowerCase().includes(contactName.replace(' ', ''))) {
+                            searchedFor.push(`${h.title || h.url} (${new URL(h.url).hostname})`);
+                        }
+                    }
+                }
+                if (searchedFor.length > 0) {
+                    profile.searchedOnline = [...new Set(searchedFor)].slice(0, 5);
+                }
+                safDb.close();
+            }
+            // --- Assessment ---
+            const tier = profile.messaging?.tier || 'unknown';
+            const freq = profile.messaging?.frequency || 'unknown';
+            const hasCalls = profile.calls?.totalCalls > 0;
+            let flexibility = 'unknown';
+            if (tier === 'inner circle') {
+                flexibility = 'very flexible — they know you well, would understand schedule changes without explanation';
+            }
+            else if (tier === 'close friend') {
+                flexibility = 'flexible — a quick heads-up is enough, they\'d get it';
+            }
+            else if (tier === 'regular contact') {
+                flexibility = 'moderate — worth a thoughtful message if rescheduling';
+            }
+            else if (tier === 'occasional contact' || tier === 'acquaintance') {
+                flexibility = 'low — changing plans could damage the relationship, be careful';
+            }
+            profile.assessment = {
+                relationshipTier: tier,
+                communicationFrequency: freq,
+                callsEachOther: hasCalls,
+                flexibility,
+            };
+            return JSON.stringify(profile, null, 1);
+        }
+    },
+    // 15. Cross-reference interests with browsing
+    {
+        name: 'get_interests_for_plans',
+        description: 'Find what the user has been browsing/searching that could be relevant for making plans — restaurants, activities, events, locations. Use this to suggest specific places or activities when making plans with someone.',
+        parameters: {
+            type: 'object',
+            properties: {
+                category: { type: 'string', description: 'Category to search for: "food", "events", "places", "activities", or "all". Default "all".' },
+                location: { type: 'string', description: 'Optional location filter.' },
+            },
+            required: []
+        },
+        async execute(params) {
+            const category = params.category || 'all';
+            const location = params.location;
+            const safDb = openDb(join(home, 'Library/Safari/History.db'));
+            if (!safDb)
+                return JSON.stringify({ error: 'Safari not available' });
+            const history = safeQuery(safDb, `SELECT hi.url, hv.title, datetime(hv.visit_time + ${APPLE_EPOCH}, 'unixepoch', 'localtime') as visited
+         FROM history_visits hv JOIN history_items hi ON hv.history_item = hi.id
+         WHERE hv.visit_time > ? ORDER BY hv.visit_time DESC LIMIT 3000`, [daysAgoApple(30)]);
+            const foodDomains = ['doordash.com', 'ubereats.com', 'yelp.com', 'opentable.com', 'resy.com', 'grubhub.com', 'seamless.com', 'toasttab.com'];
+            const eventDomains = ['eventbrite.com', 'meetup.com', 'dice.fm', 'seatgeek.com', 'ticketmaster.com', 'stubhub.com', 'lu.ma'];
+            const placeDomains = ['google.com/maps', 'yelp.com', 'tripadvisor.com', 'airbnb.com', 'zillow.com'];
+            const food = [];
+            const events = [];
+            const places = [];
+            const searches = [];
+            for (const h of history) {
+                if (!h.title || h.title.length < 5)
+                    continue;
+                try {
+                    const domain = new URL(h.url).hostname.replace('www.', '');
+                    const entry = { title: h.title, domain, when: h.visited };
+                    if (foodDomains.some(d => domain.includes(d)))
+                        food.push(entry);
+                    if (eventDomains.some(d => domain.includes(d)))
+                        events.push(entry);
+                    if (placeDomains.some(d => domain.includes(d)))
+                        places.push(entry);
+                    // Food/restaurant searches
+                    const u = new URL(h.url);
+                    const q = u.searchParams.get('q') || u.searchParams.get('query') || '';
+                    if (q && (q.match(/restaurant|food|dinner|lunch|brunch|cafe|bar|sushi|pizza|thai|italian|mexican/i) ||
+                        (location && q.toLowerCase().includes(location.toLowerCase())))) {
+                        searches.push(q);
+                    }
+                }
+                catch { }
+            }
+            safDb.close();
+            const results = {};
+            if (category === 'all' || category === 'food')
+                results.food = { recent: food.slice(0, 10), searches: [...new Set(searches)].slice(0, 10) };
+            if (category === 'all' || category === 'events')
+                results.events = events.slice(0, 10);
+            if (category === 'all' || category === 'places')
+                results.places = places.slice(0, 10);
+            return JSON.stringify(results, null, 1);
+        }
+    },
+    // 16. Get conversation thread
+    {
+        name: 'get_conversation',
+        description: 'Get the full recent conversation thread between the user and a specific person. Shows back-and-forth messages in order.',
+        parameters: {
+            type: 'object',
+            properties: {
+                contact: { type: 'string', description: 'Contact name to get conversation with.' },
+                days: { type: 'number', description: 'Days back. Default 2.' },
+                limit: { type: 'number', description: 'Max messages. Default 30.' },
+            },
+            required: ['contact']
+        },
+        async execute(params) {
+            const db = openDb(join(home, 'Library/Messages/chat.db'));
+            if (!db)
+                return JSON.stringify({ error: 'not available' });
+            const contactName = params.contact.toLowerCase();
+            const days = params.days || 2;
+            const maxMsgs = params.limit || 30;
+            const handles = safeQuery(db, 'SELECT ROWID, id FROM handle');
+            const handleMap = new Map(handles.map(h => [h.ROWID, h.id]));
+            // Find matching handle IDs
+            const matchingHandles = handles.filter(h => {
+                const name = resolveName(h.id);
+                return name.toLowerCase().includes(contactName);
+            }).map(h => h.ROWID);
+            if (matchingHandles.length === 0) {
+                db.close();
+                return JSON.stringify({ error: `No contact matching "${params.contact}"` });
+            }
+            const agoNano = (BigInt(daysAgoUnix(days) - APPLE_EPOCH) * BigInt(1e9)).toString();
+            const placeholders = matchingHandles.map(() => '?').join(',');
+            const msgs = safeQuery(db, `SELECT text, date, is_from_me, handle_id FROM message
+         WHERE handle_id IN (${placeholders}) AND date > ?
+         ORDER BY date ASC`, [...matchingHandles, agoNano]);
+            const thread = msgs.filter(m => m.text && !isReaction(m.text)).slice(-maxMsgs).map(m => {
+                const dateSeconds = Number(BigInt(m.date) / BigInt(1e9)) + APPLE_EPOCH;
+                return {
+                    from: m.is_from_me ? getUserName() : resolveName(handleMap.get(m.handle_id) || ''),
+                    text: m.text.slice(0, 300),
+                    when: dayjs.unix(dateSeconds).format('ddd MMM D h:mm A'),
+                };
+            });
+            db.close();
+            return JSON.stringify({ contact: params.contact, thread }, null, 1);
+        }
+    },
+];
+/** Build OpenAI-compatible tool schemas for API calls */
+export function getToolSchemas() {
+    return TOOLS.map(t => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+/** Execute a tool by name */
+export async function executeTool(name, params) {
+    const tool = TOOLS.find(t => t.name === name);
+    if (!tool)
+        return JSON.stringify({ error: `Unknown tool: ${name}` });
+    try {
+        return await tool.execute(params);
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Tool ${name} failed: ${String(e)}` });
+    }
+}