life-pulse 2.2.2 → 2.3.0

package/dist/agent.js

@@ -94,12 +94,12 @@ function buildCustomMcpServer(onCard) {
     });
 }
 // ─── Executive Operating System prompt ──────────────────────────
-function buildOrchestratorPrompt() {
+async function buildOrchestratorPrompt() {
     const delta = buildDeltaContext();
     const todos = buildTodoContext();
     const profile = buildProfile();
     const name = profile.name;
-    const crm = buildCRM();
+    const crm = await buildCRM();
     const crmContext = buildCRMContext(crm);
     const projectSection = profile.projects.length > 0
         ? `\n- Active projects: ${profile.projects.join(', ')}`
@@ -387,7 +387,7 @@ RULES:
     for await (const msg of query({
         prompt,
         options: {
-            systemPrompt: buildOrchestratorPrompt(),
+            systemPrompt: await buildOrchestratorPrompt(),
             model: ORCHESTRATOR_MODEL,
             env,
             mcpServers,

package/dist/cli.js

@@ -83,7 +83,7 @@ async function fetchCalendarContext() {
     return '';
 }
 async function showCRM(apiKey, opts) {
-    const crm = buildCRM();
+    const crm = await buildCRM();
     if (!crm.threads.length || !apiKey) {
         opts?.spinner?.stop();
         return false;
@@ -686,9 +686,9 @@ async function main() {
     }
     // Generate knowledge bases from CRM on startup
     try {
-        const crm = buildCRM();
+        const crm = await buildCRM();
         if (crm.threads.length)
-            updateAutoKnowledge(crm);
+            await updateAutoKnowledge(crm);
     }
     catch { }
     // Periodic progress save (every 5 min while running)

package/dist/crm.d.ts

@@ -1,12 +1,11 @@
 /**
  * Relationship Map — high-touch contact intelligence.
  *
- * Queries iMessage DB directly with CTE-based SQL:
- * - Response time pairing (their msg → your first reply)
- * - Ghost detection (waiting on you / you're waiting on them)
- * - Thread temperature from message velocity
- * - Recent message pulls for LLM-powered relationship summaries
- * - Filters out group chats, tapbacks, business messages
+ * Two data paths:
+ * 1. RPLY API (localhost:19851) — preferred, no FDA needed, multi-platform
+ * 2. Direct iMessage SQLite — fallback when RPLY unavailable
+ *
+ * Both paths produce the same CRM/ThreadState interface.
  */
 export interface ThreadState {
     name: string;
@@ -35,7 +34,7 @@ export interface CRM {
     yourAvgResponseSec: number | null;
     generatedAt: string;
 }
-export declare function buildCRM(): CRM;
+export declare function buildCRM(): Promise<CRM>;
 export declare function streamEnrichedCRM(crm: CRM, apiKey: string, opts?: {
     calendarContext?: string;
     timeOfDay?: string;

package/dist/crm.js

@@ -1,17 +1,17 @@
 /**
  * Relationship Map — high-touch contact intelligence.
  *
- * Queries iMessage DB directly with CTE-based SQL:
- * - Response time pairing (their msg → your first reply)
- * - Ghost detection (waiting on you / you're waiting on them)
- * - Thread temperature from message velocity
- * - Recent message pulls for LLM-powered relationship summaries
- * - Filters out group chats, tapbacks, business messages
+ * Two data paths:
+ * 1. RPLY API (localhost:19851) — preferred, no FDA needed, multi-platform
+ * 2. Direct iMessage SQLite — fallback when RPLY unavailable
+ *
+ * Both paths produce the same CRM/ThreadState interface.
  */
 import { homedir } from 'os';
 import { join } from 'path';
 import { openDb, safeQuery } from './db.js';
 import { resolveName } from './contacts.js';
+import * as rply from './rply-client.js';
 import Anthropic from '@anthropic-ai/sdk';
 import dayjs from 'dayjs';
 import relativeTime from 'dayjs/plugin/relativeTime.js';
@@ -28,92 +28,196 @@ function nanoToDay(nano) {
     const n = typeof nano === 'bigint' ? nano : BigInt(Math.trunc(Number(nano)));
     return dayjs.unix(Number(n / NANO) + APPLE_EPOCH);
 }
-// ─── Build CRM ──────────────────────────────────────────────────
-export function buildCRM() {
+function emptyCRM() {
+    return { threads: [], yourAvgResponseSec: null, generatedAt: dayjs().toISOString() };
+}
+// ─── Build CRM (async, RPLY-first) ──────────────────────────────
+export async function buildCRM() {
+    if (await rply.isAvailable()) {
+        try {
+            const crm = await buildCRMFromRPLY();
+            if (crm.threads.length > 0)
+                return crm;
+        }
+        catch (e) {
+            process.stderr.write(`  rply crm fallback: ${e instanceof Error ? e.message : String(e)}\n`);
+        }
+    }
+    return buildCRMFromSQLite();
+}
+// ─── RPLY Path ──────────────────────────────────────────────────
+async function buildCRMFromRPLY() {
+    // Fetch top 50 iMessage conversations (non-group, sorted by recency)
+    const result = await rply.listConversations({ platform: 'system', limit: 50 });
+    if (!result?.data.length)
+        return emptyCRM();
+    const convos = result.data.filter(c => !c.is_group_chat && c.title.length > 2);
+    // Fetch messages for top 30 in parallel
+    const top = convos.slice(0, 30);
+    const msgResults = await Promise.all(top.map(c => rply.listMessages(c.id, { limit: 200 })));
+    const now = dayjs();
+    const ago30 = now.subtract(30, 'day');
+    const ago60 = now.subtract(60, 'day');
+    const threads = [];
+    const allResponseTimes = [];
+    for (let i = 0; i < top.length; i++) {
+        const conv = top[i];
+        // Messages: index 0 = newest, index N = oldest
+        const msgs = (msgResults[i]?.data || []).filter(m => m.content?.type === 'text' && m.content.text);
+        if (!msgs.length)
+            continue;
+        // ── msgs30d
+        const msgs30d = msgs.filter(m => dayjs(m.date).isAfter(ago30)).length;
+        // ── Response time pairs: each received → first sent after it
+        let totalResponseSec = 0;
+        let pairs = 0;
+        for (let j = msgs.length - 1; j >= 0; j--) {
+            if (msgs[j].direction !== 'received')
+                continue;
+            const received = dayjs(msgs[j].date);
+            if (received.isBefore(ago30))
+                continue;
+            for (let k = j - 1; k >= 0; k--) {
+                if (msgs[k].direction === 'sent') {
+                    const gap = dayjs(msgs[k].date).diff(received, 'second');
+                    if (gap > 0 && gap < 14 * 86400) {
+                        totalResponseSec += gap;
+                        pairs++;
+                    }
+                    break;
+                }
+            }
+        }
+        const avgResponseSec = pairs >= 3 ? totalResponseSec / pairs : null;
+        if (avgResponseSec != null && avgResponseSec < 604800) {
+            allResponseTimes.push({ avg: avgResponseSec, pairs });
+        }
+        // ── Last message + ghost detection
+        const lastMsg = buildLastMsg(msgs[0], now);
+        const { waitingOnYou, waitingOnThem, waitingSince, silentDays } = buildGhostState(msgs[0], now);
+        // ── Thread temperature
+        const threadTemp = silentDays <= 1 ? 'hot' : silentDays <= 3 ? 'warm' : silentDays <= 7 ? 'cooling' : 'cold';
+        // ── Monthly trend
+        const recent = msgs.filter(m => dayjs(m.date).isAfter(ago30)).length;
+        const prior = msgs.filter(m => { const d = dayjs(m.date); return d.isAfter(ago60) && !d.isAfter(ago30); }).length;
+        let monthlyTrend = null;
+        const ratio = prior > 0 ? recent / prior : recent > 0 ? 2 : 0;
+        if (ratio > 0)
+            monthlyTrend = ratio > 1.3 ? 'rising' : ratio < 0.7 ? 'declining' : 'stable';
+        // ── Recent snippets (for LLM enrichment)
+        const recentSnippets = msgs
+            .filter(m => dayjs(m.date).isAfter(ago30))
+            .slice(0, 40)
+            .map(m => `${m.direction === 'sent' ? '→' : '←'} ${m.content.text.slice(0, 100)}`);
+        threads.push({
+            name: conv.title, handle: conv.id,
+            msgs30d, avgResponseSec, conversationPairs: pairs,
+            lastMsg, waitingOnYou, waitingOnThem, waitingSince,
+            silentDays, threadTemp, monthlyTrend,
+            recentSnippets: recentSnippets.slice(0, 30),
+        });
+    }
+    threads.sort((a, b) => b.msgs30d - a.msgs30d);
+    const yourAvg = allResponseTimes.length > 0
+        ? allResponseTimes.reduce((s, r) => s + r.avg * r.pairs, 0)
+            / allResponseTimes.reduce((s, r) => s + r.pairs, 0)
+        : null;
+    return { threads: threads.slice(0, 25), yourAvgResponseSec: yourAvg, generatedAt: now.toISOString() };
+}
+function buildLastMsg(msg, now) {
+    if (!msg)
+        return null;
+    const when = dayjs(msg.date);
+    const daysDiff = now.diff(when, 'day');
+    if (daysDiff < -1 || daysDiff > 365)
+        return null;
+    return {
+        text: msg.content.text.slice(0, 120),
+        fromThem: msg.direction === 'received',
+        when: when.toISOString(),
+        ago: when.fromNow(),
+    };
+}
+function buildGhostState(msg, now) {
+    let waitingOnYou = false, waitingOnThem = false, waitingSince = null, silentDays = 99;
+    if (!msg)
+        return { waitingOnYou, waitingOnThem, waitingSince, silentDays };
+    const when = dayjs(msg.date);
+    const daysDiff = now.diff(when, 'day');
+    if (daysDiff < -1 || daysDiff > 365)
+        return { waitingOnYou, waitingOnThem, waitingSince, silentDays };
+    silentDays = daysDiff;
+    if (msg.direction === 'received' && now.diff(when, 'hour') > 4) {
+        waitingOnYou = true;
+        waitingSince = when.fromNow(true);
+    }
+    else if (msg.direction === 'sent' && now.diff(when, 'hour') > 24) {
+        waitingOnThem = true;
+        waitingSince = when.fromNow(true);
+    }
+    return { waitingOnYou, waitingOnThem, waitingSince, silentDays };
+}
+// ─── SQLite Path (existing, unchanged) ──────────────────────────
+function buildCRMFromSQLite() {
     const home = homedir();
     const db = openDb(join(home, 'Library/Messages/chat.db'));
     if (!db)
-        return { threads: [], yourAvgResponseSec: null, generatedAt: dayjs().toISOString() };
+        return emptyCRM();
     const now = nowNano();
     const ago30 = agoNano(30);
-    const ago14 = agoNano(14);
     const ago90 = agoNano(90);
     // ── 1. Response time per contact (ConversationPairs CTE) ──
-    // Pairs each incoming msg with your first reply within 14 days
     const responseTimes = safeQuery(db, `
     WITH NonGroupChats AS (
       SELECT chat_id FROM chat_handle_join GROUP BY chat_id HAVING COUNT(DISTINCT handle_id) = 1
     ),
     ConversationPairs AS (
-      SELECT
-        m1.handle_id as contact_id,
-        m1.date as received_date,
-        MIN(m2.date) as first_response_date
+      SELECT m1.handle_id as contact_id, m1.date as received_date, MIN(m2.date) as first_response_date
       FROM message AS m1
       JOIN chat_message_join cmj ON m1.ROWID = cmj.message_id
       JOIN NonGroupChats ngc ON ngc.chat_id = cmj.chat_id
       LEFT JOIN message AS m2
-        ON m2.handle_id = m1.handle_id
-        AND m2.date > m1.date
-        AND m2.is_from_me = 1
+        ON m2.handle_id = m1.handle_id AND m2.date > m1.date AND m2.is_from_me = 1
         AND m2.date <= m1.date + 1209600000000000
-      WHERE m1.is_from_me = 0
-        AND m1.date >= ?
-        AND m1.date <= ?
-        AND m1.associated_message_type = 0
-      GROUP BY m1.ROWID
-      HAVING first_response_date IS NOT NULL
+      WHERE m1.is_from_me = 0 AND m1.date >= ? AND m1.date <= ? AND m1.associated_message_type = 0
+      GROUP BY m1.ROWID HAVING first_response_date IS NOT NULL
     )
-    SELECT
-      h.id as handle_id,
-      COUNT(*) as conversation_pairs,
+    SELECT h.id as handle_id, COUNT(*) as conversation_pairs,
       AVG((cp.first_response_date - cp.received_date) / 1000000000.0) as avg_response_seconds
-    FROM ConversationPairs cp
-    JOIN handle h ON h.ROWID = cp.contact_id
-    GROUP BY h.id
-    HAVING conversation_pairs >= 3 AND avg_response_seconds < 604800
-    ORDER BY avg_response_seconds ASC
-    LIMIT 50
+    FROM ConversationPairs cp JOIN handle h ON h.ROWID = cp.contact_id
+    GROUP BY h.id HAVING conversation_pairs >= 3 AND avg_response_seconds < 604800
+    ORDER BY avg_response_seconds ASC LIMIT 50
   `, [ago30, now]);
     const responseMap = new Map(responseTimes.map(r => [r.handle_id, r]));
-    // ── 2. Top contacts by 30-day volume (non-group only) ──
+    // ── 2. Top contacts by 30-day volume ──
     const topContacts = safeQuery(db, `
     WITH NonGroupChats AS (
       SELECT chat_id FROM chat_handle_join GROUP BY chat_id HAVING COUNT(DISTINCT handle_id) = 1
     )
     SELECT h.id as handle_id, COUNT(*) as msg_count
-    FROM message m
-    JOIN handle h ON m.handle_id = h.ROWID
+    FROM message m JOIN handle h ON m.handle_id = h.ROWID
     JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
     JOIN NonGroupChats ngc ON ngc.chat_id = cmj.chat_id
-    WHERE m.date >= ? AND m.date <= ?
-      AND m.associated_message_type = 0
-      AND h.id NOT LIKE 'urn:biz:%'
-    GROUP BY h.id
-    ORDER BY msg_count DESC
-    LIMIT 30
+    WHERE m.date >= ? AND m.date <= ? AND m.associated_message_type = 0 AND h.id NOT LIKE 'urn:biz:%'
+    GROUP BY h.id ORDER BY msg_count DESC LIMIT 30
   `, [ago30, now]);
-    // ── 3. Last message per contact (who sent, when, what) ──
+    // ── 3. Last message per contact ──
     const lastMessages = safeQuery(db, `
     WITH NonGroupChats AS (
       SELECT chat_id FROM chat_handle_join GROUP BY chat_id HAVING COUNT(DISTINCT handle_id) = 1
     ),
     RankedMessages AS (
       SELECT h.id as handle_id, m.text, m.is_from_me, m.date,
-             ROW_NUMBER() OVER (PARTITION BY h.id ORDER BY m.date DESC) as rn
-      FROM message m
-      JOIN handle h ON m.handle_id = h.ROWID
+        ROW_NUMBER() OVER (PARTITION BY h.id ORDER BY m.date DESC) as rn
+      FROM message m JOIN handle h ON m.handle_id = h.ROWID
       JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
       JOIN NonGroupChats ngc ON ngc.chat_id = cmj.chat_id
-      WHERE m.text IS NOT NULL AND m.text != ''
-        AND m.associated_message_type = 0
-        AND m.date >= ?
+      WHERE m.text IS NOT NULL AND m.text != '' AND m.associated_message_type = 0 AND m.date >= ?
     )
-    SELECT handle_id, text, is_from_me, date
-    FROM RankedMessages WHERE rn = 1
+    SELECT handle_id, text, is_from_me, date FROM RankedMessages WHERE rn = 1
   `, [ago90]);
     const lastMsgMap = new Map(lastMessages.map(m => [m.handle_id, m]));
-    // ── 4. Monthly trend (compare last 30d vs prior 30d) ──
+    // ── 4. Monthly trend ──
     const ago60 = agoNano(60);
     const monthlyComparison = safeQuery(db, `
     WITH NonGroupChats AS (
@@ -122,46 +226,39 @@ export function buildCRM() {
     SELECT h.id as handle_id,
       COUNT(CASE WHEN m.date >= ? THEN 1 END) as recent,
       COUNT(CASE WHEN m.date >= ? AND m.date < ? THEN 1 END) as prior
-    FROM message m
-    JOIN handle h ON m.handle_id = h.ROWID
+    FROM message m JOIN handle h ON m.handle_id = h.ROWID
     JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
     JOIN NonGroupChats ngc ON ngc.chat_id = cmj.chat_id
     WHERE m.date >= ? AND m.associated_message_type = 0
     GROUP BY h.id
   `, [ago30, ago60, ago30, ago60]);
     const trendMap = new Map(monthlyComparison.map(t => [t.handle_id, t]));
-    // ── 5. Recent messages per contact (for relationship summaries) ──
+    // ── 5. Recent messages per contact ──
     const recentMessages = safeQuery(db, `
     WITH NonGroupChats AS (
       SELECT chat_id FROM chat_handle_join GROUP BY chat_id HAVING COUNT(DISTINCT handle_id) = 1
     ),
     RankedRecent AS (
       SELECT h.id as handle_id, m.text, m.is_from_me, m.date,
-             ROW_NUMBER() OVER (PARTITION BY h.id ORDER BY m.date DESC) as rn
-      FROM message m
-      JOIN handle h ON m.handle_id = h.ROWID
+        ROW_NUMBER() OVER (PARTITION BY h.id ORDER BY m.date DESC) as rn
+      FROM message m JOIN handle h ON m.handle_id = h.ROWID
       JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
       JOIN NonGroupChats ngc ON ngc.chat_id = cmj.chat_id
-      WHERE m.text IS NOT NULL AND m.text != ''
-        AND m.associated_message_type = 0
-        AND m.date >= ?
+      WHERE m.text IS NOT NULL AND m.text != '' AND m.associated_message_type = 0 AND m.date >= ?
     )
-    SELECT handle_id, text, is_from_me, date
-    FROM RankedRecent WHERE rn <= 40
+    SELECT handle_id, text, is_from_me, date FROM RankedRecent WHERE rn <= 40
     ORDER BY handle_id, date DESC
   `, [ago30]);
     const snippetMap = new Map();
     for (const m of recentMessages) {
         const arr = snippetMap.get(m.handle_id) || [];
-        const dir = m.is_from_me ? '→' : '←';
-        arr.push(`${dir} ${(m.text || '').slice(0, 100)}`);
+        arr.push(`${m.is_from_me ? '→' : '←'} ${(m.text || '').slice(0, 100)}`);
         snippetMap.set(m.handle_id, arr);
     }
     db.close();
     // ── Assemble threads ──
     const seen = new Set();
     const threads = [];
-    // Include all top contacts + anyone with response time data
     const allHandles = new Set([
         ...topContacts.map(c => c.handle_id),
         ...responseTimes.map(r => r.handle_id),
@@ -171,7 +268,7 @@ export function buildCRM() {
         if (name === 'Unknown' || name === handleId || seen.has(name))
             continue;
         if (name.length <= 2)
-            continue; // skip bots/short handles
+            continue;
         seen.add(name);
         const contact = topContacts.find(c => c.handle_id === handleId);
         const response = responseMap.get(handleId);
@@ -190,29 +287,19 @@ export function buildCRM() {
                 const fromThem = last.is_from_me === 0;
                 lastMsg = {
                     text: (last.text || '').slice(0, 120),
-                    fromThem,
-                    when: when.toISOString(),
-                    ago: when.fromNow(),
+                    fromThem, when: when.toISOString(), ago: when.fromNow(),
                 };
-                if (fromThem) {
-                    const hoursSince = dayjs().diff(when, 'hour');
-                    if (hoursSince > 4) {
-                        waitingOnYou = true;
-                        waitingSince = when.fromNow(true);
-                    }
+                if (fromThem && dayjs().diff(when, 'hour') > 4) {
+                    waitingOnYou = true;
+                    waitingSince = when.fromNow(true);
                 }
-                else {
-                    const hoursSince = dayjs().diff(when, 'hour');
-                    if (hoursSince > 24) {
-                        waitingOnThem = true;
-                        waitingSince = when.fromNow(true);
-                    }
+                else if (!fromThem && dayjs().diff(when, 'hour') > 24) {
+                    waitingOnThem = true;
+                    waitingSince = when.fromNow(true);
                 }
             }
         }
-        const threadTemp = silentDays <= 1 ? 'hot' :
-            silentDays <= 3 ? 'warm' :
-                silentDays <= 7 ? 'cooling' : 'cold';
+        const threadTemp = silentDays <= 1 ? 'hot' : silentDays <= 3 ? 'warm' : silentDays <= 7 ? 'cooling' : 'cold';
         let monthlyTrend = null;
         if (trend) {
             const ratio = trend.prior > 0 ? trend.recent / trend.prior : trend.recent > 0 ? 2 : 0;
@@ -228,21 +315,15 @@ export function buildCRM() {
             recentSnippets: snippetMap.get(handleId)?.slice(0, 30),
         });
     }
-    // Sort by closeness: most frequent first
     threads.sort((a, b) => b.msgs30d - a.msgs30d);
-    // Your overall avg response time
     const allPairs = responseTimes.filter(r => r.avg_response_seconds < 604800);
     const yourAvg = allPairs.length > 0
         ? allPairs.reduce((sum, r) => sum + r.avg_response_seconds * r.conversation_pairs, 0)
             / allPairs.reduce((sum, r) => sum + r.conversation_pairs, 0)
         : null;
-    return {
-        threads: threads.slice(0, 25),
-        yourAvgResponseSec: yourAvg,
-        generatedAt: dayjs().toISOString(),
-    };
+    return { threads: threads.slice(0, 25), yourAvgResponseSec: yourAvg, generatedAt: dayjs().toISOString() };
 }
-// ─── Stream-enrich CRM: contacts drip in with deep summaries, then a brief ──
+// ─── Stream-enrich CRM ──────────────────────────────────────────
 export async function* streamEnrichedCRM(crm, apiKey, opts) {
     const top = crm.threads.slice(0, 10);
     if (!top.length || !apiKey) {
@@ -268,7 +349,6 @@ export async function* streamEnrichedCRM(crm, apiKey, opts) {
     const nameMap = new Map(top.map(t => [t.name.toLowerCase(), t]));
     const yielded = new Set();
     const ready = [];
-    // Multi-line accumulator for current contact
     let curName = null;
     let curLines = [];
     let curPriority = null;
@@ -326,7 +406,6 @@ STYLE GUIDE:
 ${contactBlocks}`,
                 }],
         });
-        // Collect full response then parse — streaming line-by-line was unreliable
         const response = await stream.finalMessage();
         const fullText = response.content
             .filter(b => b.type === 'text')
@@ -367,12 +446,10 @@ ${contactBlocks}`,
             }
         }
         flushContact();
-        // Yield enriched contacts one by one (drip-feed effect)
         while (ready.length)
             yield ready.shift();
-        if (briefLines.length && opts?.onBrief) {
+        if (briefLines.length && opts?.onBrief)
             opts.onBrief(briefLines.join(' '));
-        }
     }
     catch (err) {
         process.stderr.write(`\x1B[2K\r  enrichment error: ${err instanceof Error ? err.stack || err.message : String(err)}\n`);

package/dist/installer.js

@@ -32,6 +32,7 @@ import { startGateway } from './sms-gateway.js';
 import { renderCRMList, renderBrief, Spinner, GRN, DIM, HD, MID, RED } from './tui.js';
 import { saveContactSummaries } from './intelligence.js';
 import { startSession } from './session-progress.js';
+import * as rply from './rply-client.js';
 const BASE = join(homedir(), '.life-pulse');
 const STATE_PATH = join(BASE, 'install-state.json');
 function loadState() {
@@ -74,6 +75,19 @@ async function prompt(question) {
         });
     });
 }
+// ─── Platform Hints ─────────────────────────────────────────────
+const PLATFORM_HINTS = {
+    slack: 'sign into slack.com in Safari',
+    x: 'sign into x.com in Safari',
+    email: 'sign into gmail.com in Safari',
+    instagram: 'sign into instagram.com in Safari',
+    linkedin: 'sign into linkedin.com in Safari',
+    whatsApp: 'sign into web.whatsapp.com in Safari',
+    telegram: 'sign into web.telegram.org in Safari',
+};
+function platformHint(platform) {
+    return PLATFORM_HINTS[platform] || '';
+}
 // ─── Main Installer Flow ────────────────────────────────────────
 export async function runInstaller(apiKey) {
     const state = loadState();
@@ -162,6 +176,28 @@ export async function runInstaller(apiKey) {
         if (skills.active.length) {
             console.log(DIM(`    ${skills.active.length} skills activated`));
         }
+        // RPLY platform connectivity
+        const rplyStatus = await rply.status();
+        if (rplyStatus) {
+            const active = rplyStatus.platforms.filter(p => p.is_available && p.is_enabled);
+            const inactive = rplyStatus.platforms.filter(p => !p.is_available || !p.is_enabled);
+            console.log();
+            for (const p of active) {
+                console.log(`    ${GRN('✓')} ${p.display_name}`);
+            }
+            for (const p of inactive) {
+                const hint = platformHint(p.platform);
+                console.log(`    ${DIM('○')} ${DIM(p.display_name)}${hint ? '  ' + DIM(hint) : ''}`);
+            }
+            if (inactive.length) {
+                console.log();
+                console.log(DIM('    sign into these services in Safari to enable them'));
+                console.log(DIM('    re-run setup after signing in'));
+            }
+        }
+        else {
+            console.log(DIM('    direct iMessage access (install rply-mac-server for multi-platform)'));
+        }
         savePlatforms(platformProfile);
         markDone(state, 'discovery');
     }
@@ -169,12 +205,12 @@ export async function runInstaller(apiKey) {
     stepHeader(4, 'Relationship Map', isDone(state, 'crm'));
     if (!isDone(state, 'crm')) {
         spinner?.start('scanning messages');
-        const crm = buildCRM();
+        const crm = await buildCRM();
         spinner?.stop();
         if (crm.threads.length) {
             renderCRMList(crm.threads);
             // Knowledge base generation
-            const knowledgeCount = updateAutoKnowledge(crm);
+            const knowledgeCount = await updateAutoKnowledge(crm);
             console.log(DIM(`    ${knowledgeCount} contact knowledge bases created`));
             // Enrichment
             if (apiKey) {
@@ -378,6 +414,14 @@ export async function runInstaller(apiKey) {
     console.log();
     console.log(chalk.bold.hex('#7AA2F7')('  Setup complete'));
     console.log();
+    // Show active platform count
+    const finalStatus = await rply.status();
+    if (finalStatus) {
+        const active = finalStatus.platforms.filter(p => p.is_available && p.is_enabled);
+        const total = finalStatus.platforms.length;
+        console.log(HD(`  ${active.length}/${total} platforms active`) + '  ' +
+            DIM(active.map(p => p.display_name).join(', ')));
+    }
     if (state.funnelUrl) {
         console.log(HD(`  Gateway: ${state.funnelUrl}/inbound`));
         console.log(DIM('  Configure rply-mac-server to POST here'));

package/dist/knowledge.d.ts

@@ -16,7 +16,7 @@ export declare function loadKnowledge(contactName: string): string;
 /** Get the knowledge directory for a contact (creates if needed) */
 export declare function getKnowledgeDir(contactName: string): string;
 /** Regenerate auto knowledge for all CRM contacts */
-export declare function updateAutoKnowledge(crm: CRM): number;
+export declare function updateAutoKnowledge(crm: CRM): Promise<number>;
 interface ConversationTurn {
     role: 'user' | 'assistant';
     content: string;

package/dist/knowledge.js

@@ -14,6 +14,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'fs';
 import { openDb, safeQuery } from './db.js';
+import * as rply from './rply-client.js';
 const BASE = join(homedir(), '.life-pulse');
 const KNOWLEDGE_DIR = join(BASE, 'knowledge');
 const CONVERSATIONS_DIR = join(BASE, 'conversations');
@@ -93,8 +94,23 @@ function writeRelationship(dir, thread) {
         lines.push(`Waiting on them since ${thread.waitingSince}`);
     writeFileSync(join(dir, 'relationship.txt'), lines.join('\n'), 'utf-8');
 }
-/** Update recent-threads.txt from iMessage DB */
-function writeRecentThreads(dir, handle) {
+/** Update recent-threads.txt — RPLY first, SQLite fallback */
+async function writeRecentThreads(dir, handle) {
+    // ── RPLY path ──
+    if (await rply.isAvailable()) {
+        const msgs = await rply.listMessages(handle, { limit: MAX_RECENT_MSGS });
+        if (msgs?.data.length) {
+            const lines = msgs.data
+                .filter(m => m.content?.type === 'text' && m.content.text)
+                .reverse() // oldest first
+                .map(m => `${m.direction === 'sent' ? '→' : '←'} ${m.content.text.slice(0, 200)}`);
+            if (lines.length) {
+                writeFileSync(join(dir, 'recent-threads.txt'), lines.join('\n'), 'utf-8');
+                return;
+            }
+        }
+    }
+    // ── SQLite fallback ──
     const db = openDb(join(homedir(), 'Library/Messages/chat.db'));
     if (!db)
         return;
@@ -116,8 +132,8 @@ function writeRecentThreads(dir, handle) {
         if (!rows.length)
             return;
         const lines = rows.reverse().map(r => {
-            const dir = r.is_from_me ? '→' : '←';
-            return `${dir} ${(r.text || '').slice(0, 200)}`;
+            const d = r.is_from_me ? '→' : '←';
+            return `${d} ${(r.text || '').slice(0, 200)}`;
         });
         writeFileSync(join(dir, 'recent-threads.txt'), lines.join('\n'), 'utf-8');
     }
@@ -126,7 +142,7 @@ function writeRecentThreads(dir, handle) {
     }
 }
 /** Regenerate auto knowledge for all CRM contacts */
-export function updateAutoKnowledge(crm) {
+export async function updateAutoKnowledge(crm) {
     mkdirSync(KNOWLEDGE_DIR, { recursive: true });
     let count = 0;
     for (const thread of crm.threads) {
@@ -134,7 +150,7 @@ export function updateAutoKnowledge(crm) {
             continue;
         const dir = getKnowledgeDir(thread.name);
         writeRelationship(dir, thread);
-        writeRecentThreads(dir, thread.handle);
+        await writeRecentThreads(dir, thread.handle);
         count++;
     }
     return count;

package/dist/message-loop.js

@@ -129,7 +129,7 @@ function fetchNewMessages() {
     }
 }
 /** Resolve a handle to a contact name */
-function resolveHandle(handle) {
+async function resolveHandle(handle) {
     try {
         const profile = buildProfile();
         const lower = handle.toLowerCase();
@@ -141,7 +141,7 @@ function resolveHandle(handle) {
     catch { }
     // Fallback: use CRM for better resolution
     try {
-        const crm = buildCRM();
+        const crm = await buildCRM();
         for (const t of crm.threads) {
             if (t.handle === handle) {
                 const tier = t.msgs30d > 50 ? 'T1' : t.msgs30d > 15 ? 'T2' : t.msgs30d > 5 ? 'T3' : 'T4';
@@ -191,7 +191,7 @@ async function pollCycle(config) {
             skippedCount++;
             continue;
         }
-        const { name, tier } = resolveHandle(msg.handle);
+        const { name, tier } = await resolveHandle(msg.handle);
         // Only respond to configured tiers
         if (!config.respondTiers.includes(tier)) {
             processed.add(msg.rowid);

package/dist/rply-client.d.ts

@@ -0,0 +1,98 @@
+/**
+ * RPLY API client — localhost:19851
+ *
+ * Unified messaging API. When available, replaces direct SQLite access
+ * to iMessage/chat.db, removing the Full Disk Access requirement.
+ */
+export interface RPLYConversation {
+    id: string;
+    title: string;
+    platform: string;
+    last_message_date: string;
+    unread_count: number;
+    is_group_chat: boolean;
+    is_never_reply: boolean;
+    is_dismissed: boolean;
+    priority?: string;
+    participants: RPLYParticipant[];
+    reply?: RPLYReply;
+    messages_load_state: string;
+}
+export interface RPLYParticipant {
+    display_name: string;
+    full_name: string;
+    identifier: string;
+    platform: string;
+}
+export interface RPLYReply {
+    id: string;
+    text: string;
+    original_text: string;
+    classification_reason: string;
+    reply_date: string;
+    was_edited: boolean;
+}
+export interface RPLYMessage {
+    direction: 'sent' | 'received';
+    date: string;
+    content: {
+        type: string;
+        text: string;
+    };
+    id?: string;
+}
+export interface RPLYContact {
+    display_name: string;
+    full_name: string;
+    identifier: string;
+    platform: string;
+}
+export interface RPLYSearchResult {
+    message: RPLYMessage & {
+        id: string;
+    };
+    conversation_id: string;
+}
+export interface RPLYStatus {
+    conversation_count: number;
+    version: string;
+    is_loading: boolean;
+    platforms: {
+        platform: string;
+        display_name: string;
+        is_available: boolean;
+        is_enabled: boolean;
+    }[];
+}
+interface Paginated<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export declare function isAvailable(): Promise<boolean>;
+export declare function resetCache(): void;
+export declare function status(): Promise<RPLYStatus | null>;
+export declare function listConversations(opts?: {
+    limit?: number;
+    offset?: number;
+    category?: string;
+    platform?: string;
+}): Promise<Paginated<RPLYConversation> | null>;
+export declare function getConversation(id: string): Promise<(RPLYConversation & {
+    messages: RPLYMessage[];
+}) | null>;
+export declare function listMessages(conversationId: string, opts?: {
+    limit?: number;
+    offset?: number;
+}): Promise<Paginated<RPLYMessage> | null>;
+export declare function searchConversations(q: string): Promise<RPLYConversation[] | null>;
+export declare function searchMessages(q: string, opts?: {
+    limit?: number;
+}): Promise<RPLYSearchResult[] | null>;
+export declare function listContacts(opts?: {
+    limit?: number;
+    offset?: number;
+}): Promise<Paginated<RPLYContact> | null>;
+export declare function searchContacts(q: string): Promise<RPLYContact[] | null>;
+export {};

package/dist/rply-client.js

@@ -0,0 +1,79 @@
+/**
+ * RPLY API client — localhost:19851
+ *
+ * Unified messaging API. When available, replaces direct SQLite access
+ * to iMessage/chat.db, removing the Full Disk Access requirement.
+ */
+const BASE = 'http://localhost:19851';
+const TIMEOUT = 5_000;
+// ─── Core ────────────────────────────────────────────────────
+let _available = null;
+async function get(path) {
+    try {
+        const r = await fetch(`${BASE}${path}`, { signal: AbortSignal.timeout(TIMEOUT) });
+        if (!r.ok)
+            return null;
+        return await r.json();
+    }
+    catch {
+        return null;
+    }
+}
+export async function isAvailable() {
+    if (_available !== null)
+        return _available;
+    const s = await get('/v1/status');
+    _available = s !== null && !s.is_loading;
+    return _available;
+}
+export function resetCache() { _available = null; }
+// ─── Endpoints ───────────────────────────────────────────────
+export async function status() {
+    return get('/v1/status');
+}
+export async function listConversations(opts) {
+    const p = new URLSearchParams();
+    if (opts?.limit)
+        p.set('limit', String(opts.limit));
+    if (opts?.offset)
+        p.set('offset', String(opts.offset));
+    if (opts?.category)
+        p.set('category', opts.category);
+    if (opts?.platform)
+        p.set('platform', opts.platform);
+    const qs = p.toString();
+    return get(`/v1/conversations${qs ? '?' + qs : ''}`);
+}
+export async function getConversation(id) {
+    return get(`/v1/conversations/${encodeURIComponent(id)}`);
+}
+export async function listMessages(conversationId, opts) {
+    const p = new URLSearchParams();
+    if (opts?.limit)
+        p.set('limit', String(opts.limit));
+    if (opts?.offset)
+        p.set('offset', String(opts.offset));
+    const qs = p.toString();
+    return get(`/v1/conversations/${encodeURIComponent(conversationId)}/messages${qs ? '?' + qs : ''}`);
+}
+export async function searchConversations(q) {
+    return get(`/v1/conversations/search?q=${encodeURIComponent(q)}`);
+}
+export async function searchMessages(q, opts) {
+    const p = new URLSearchParams({ q });
+    if (opts?.limit)
+        p.set('limit', String(opts.limit));
+    return get(`/v1/messages/search?${p}`);
+}
+export async function listContacts(opts) {
+    const p = new URLSearchParams();
+    if (opts?.limit)
+        p.set('limit', String(opts.limit));
+    if (opts?.offset)
+        p.set('offset', String(opts.offset));
+    const qs = p.toString();
+    return get(`/v1/contacts${qs ? '?' + qs : ''}`);
+}
+export async function searchContacts(q) {
+    return get(`/v1/contacts/search?q=${encodeURIComponent(q)}`);
+}

package/dist/tools.js

@@ -9,6 +9,7 @@ import { execSync } from 'child_process';
 import { openDb, safeQuery } from './db.js';
 import { resolveName, buildContactMap } from './contacts.js';
 import { getUserName } from './profile.js';
+import * as rply from './rply-client.js';
 import dayjs from 'dayjs';
 import { APPLE_EPOCH, CHROME_EPOCH } from './types.js';
 const home = homedir();
@@ -163,13 +164,92 @@ export const TOOLS = [
             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;
+            // ── RPLY path ──
+            if (await rply.isAvailable()) {
+                const cutoff = dayjs().subtract(days, 'day');
+                const results = [];
+                if (keyword) {
+                    const hits = await rply.searchMessages(keyword, { limit: maxResults * 2 });
+                    if (hits) {
+                        for (const h of hits) {
+                            const d = dayjs(h.message.date);
+                            if (d.isBefore(cutoff))
+                                continue;
+                            if (contactFilter) {
+                                const conv = await rply.getConversation(h.conversation_id);
+                                if (conv && !conv.title.toLowerCase().includes(contactFilter.toLowerCase()))
+                                    continue;
+                            }
+                            results.push({
+                                from: h.message.direction === 'sent' ? getUserName() : h.conversation_id,
+                                text: h.message.content.text.slice(0, 200),
+                                when: d.format('ddd MMM D h:mm A'),
+                                direction: h.message.direction,
+                            });
+                            if (results.length >= maxResults)
+                                break;
+                        }
+                        return JSON.stringify({ count: results.length, messages: results }, null, 1);
+                    }
+                }
+                if (contactFilter) {
+                    const convos = await rply.searchConversations(contactFilter);
+                    if (convos?.length) {
+                        for (const c of convos) {
+                            const msgs = await rply.listMessages(c.id, { limit: maxResults });
+                            if (!msgs)
+                                continue;
+                            for (const m of msgs.data) {
+                                if (dayjs(m.date).isBefore(cutoff))
+                                    continue;
+                                if (m.content?.type !== 'text' || !m.content.text)
+                                    continue;
+                                results.push({
+                                    from: m.direction === 'sent' ? getUserName() : c.title,
+                                    text: m.content.text.slice(0, 200),
+                                    when: dayjs(m.date).format('ddd MMM D h:mm A'),
+                                    direction: m.direction,
+                                });
+                            }
+                            if (results.length >= maxResults)
+                                break;
+                        }
+                        return JSON.stringify({ count: results.length, messages: results.slice(0, maxResults) }, null, 1);
+                    }
+                }
+                // No filter: return recent messages across conversations
+                const convos = await rply.listConversations({ limit: 20 });
+                if (convos) {
+                    for (const c of convos.data) {
+                        const msgs = await rply.listMessages(c.id, { limit: 5 });
+                        if (!msgs)
+                            continue;
+                        for (const m of msgs.data) {
+                            if (dayjs(m.date).isBefore(cutoff))
+                                continue;
+                            if (m.content?.type !== 'text' || !m.content.text)
+                                continue;
+                            results.push({
+                                from: m.direction === 'sent' ? getUserName() : c.title,
+                                text: m.content.text.slice(0, 200),
+                                when: dayjs(m.date).format('ddd MMM D h:mm A'),
+                                direction: m.direction,
+                            });
+                        }
+                        if (results.length >= maxResults)
+                            break;
+                    }
+                    return JSON.stringify({ count: results.length, messages: results.slice(0, maxResults) }, null, 1);
+                }
+            }
+            // ── SQLite fallback ──
+            const db = openDb(join(home, 'Library/Messages/chat.db'));
+            if (!db)
+                return JSON.stringify({ error: 'iMessage DB not available' });
             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();
@@ -215,6 +295,20 @@ export const TOOLS = [
             required: []
         },
         async execute(params) {
+            // ── RPLY path ──
+            if (await rply.isAvailable()) {
+                const result = await rply.listConversations({ category: 'needs_response', limit: 20 });
+                if (result) {
+                    const unanswered = result.data.map(c => ({
+                        from: c.title,
+                        text: c.reply?.text?.slice(0, 150) || '(pending)',
+                        when: dayjs(c.last_message_date).format('ddd MMM D h:mm A'),
+                        platform: c.platform,
+                    }));
+                    return JSON.stringify({ unanswered }, null, 1);
+                }
+            }
+            // ── SQLite fallback ──
             const db = openDb(join(home, 'Library/Messages/chat.db'));
             if (!db)
                 return JSON.stringify({ error: 'not available' });
@@ -223,7 +317,6 @@ export const TOOLS = [
             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))
@@ -868,6 +961,23 @@ export const TOOLS = [
         },
         async execute(params) {
             const query = params.query.toLowerCase();
+            // ── RPLY path ──
+            if (await rply.isAvailable()) {
+                const hits = await rply.searchContacts(query);
+                if (hits) {
+                    const seen = new Set();
+                    const results = hits.filter(c => {
+                        if (seen.has(c.full_name))
+                            return false;
+                        seen.add(c.full_name);
+                        return true;
+                    }).slice(0, 10).map(c => ({
+                        handle: c.identifier, name: c.full_name, platform: c.platform,
+                    }));
+                    return JSON.stringify({ results }, null, 1);
+                }
+            }
+            // ── SQLite fallback ──
             const map = buildContactMap();
             const matches = [];
             for (const [handle, name] of map) {
@@ -875,7 +985,6 @@ export const TOOLS = [
                     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; });
@@ -900,12 +1009,30 @@ export const TOOLS = [
             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 cutoff = dayjs().subtract(days, 'day');
+            // ── RPLY path ──
+            if (await rply.isAvailable()) {
+                const results = {};
+                for (const kw of keywords) {
+                    const hits = await rply.searchMessages(kw, { limit: maxPer * 2 });
+                    results[kw] = (hits || [])
+                        .filter(h => dayjs(h.message.date).isAfter(cutoff) && h.message.content?.text)
+                        .slice(0, maxPer)
+                        .map(h => ({
+                        from: h.message.direction === 'sent' ? getUserName() : h.conversation_id,
+                        text: h.message.content.text.slice(0, 200),
+                        when: dayjs(h.message.date).format('ddd MMM D h:mm A'),
+                    }));
+                }
+                return JSON.stringify(results, null, 1);
+            }
+            // ── SQLite fallback ──
+            const db = openDb(join(home, 'Library/Messages/chat.db'));
+            if (!db)
+                return JSON.stringify({ error: 'not available' });
             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();
@@ -1177,15 +1304,37 @@ export const TOOLS = [
             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 cutoff = dayjs().subtract(days, 'day');
+            // ── RPLY path ──
+            if (await rply.isAvailable()) {
+                const convos = await rply.searchConversations(params.contact);
+                if (convos?.length) {
+                    const conv = convos[0];
+                    const msgs = await rply.listMessages(conv.id, { limit: maxMsgs * 2 });
+                    if (msgs) {
+                        const thread = msgs.data
+                            .filter(m => m.content?.type === 'text' && m.content.text && dayjs(m.date).isAfter(cutoff))
+                            .reverse() // oldest first for thread view
+                            .slice(-maxMsgs)
+                            .map(m => ({
+                            from: m.direction === 'sent' ? getUserName() : conv.title,
+                            text: m.content.text.slice(0, 300),
+                            when: dayjs(m.date).format('ddd MMM D h:mm A'),
+                        }));
+                        return JSON.stringify({ contact: conv.title, thread }, null, 1);
+                    }
+                }
+                return JSON.stringify({ error: `No contact matching "${params.contact}"` });
+            }
+            // ── SQLite fallback ──
+            const db = openDb(join(home, 'Library/Messages/chat.db'));
+            if (!db)
+                return JSON.stringify({ error: 'not available' });
             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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "life-pulse",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "macOS life diagnostic — reads local data sources, generates actionable insights",
   "main": "dist/index.js",
   "scripts": {