life-pulse 1.0.0

package/dist/agent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Agentic analysis with Claude Opus orchestrator + sub-agent workers.
+ *
+ * Architecture:
+ *   Opus orchestrator → scans data → generates hypotheses → spawns workers
+ *   Workers (Haiku) → validate specific predictions using tools → report back
+ *   Opus → synthesizes validated findings into final analysis
+ */
+import type { Analysis } from './analyze.js';
+import type { ProgressSink } from './progress.js';
+export declare function runAgent(apiKey: string, progress?: ProgressSink, onCard?: (card: any) => Promise<string>): Promise<Analysis>;

package/dist/agent.js

@@ -0,0 +1,435 @@
+/**
+ * Agentic analysis with Claude Opus orchestrator + sub-agent workers.
+ *
+ * Architecture:
+ *   Opus orchestrator → scans data → generates hypotheses → spawns workers
+ *   Workers (Haiku) → validate specific predictions using tools → report back
+ *   Opus → synthesizes validated findings into final analysis
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { executeTool, TOOLS } from './tools.js';
+import { buildDeltaContext } from './state.js';
+import { buildTodoContext } from './todo.js';
+import { getUserName, buildProfile } from './profile.js';
+import { ask } from './auq.js';
+const MAX_ORCHESTRATOR_TURNS = 15;
+const MAX_WORKER_TURNS = 8;
+const ORCHESTRATOR_MODEL = 'claude-opus-4-6';
+const WORKER_MODEL = 'claude-haiku-4-5-20251001';
+const MAX_RESULT_LEN = 8000;
+const MAX_WORKER_RESULT_LEN = 4000;
+function truncateResult(result, max = MAX_RESULT_LEN) {
+    if (result.length <= max)
+        return result;
+    return result.slice(0, max) + `\n...(truncated from ${result.length} chars)`;
+}
+function buildOrchestratorPrompt() {
+    const delta = buildDeltaContext();
+    const todos = buildTodoContext();
+    const profile = buildProfile();
+    const name = profile.name;
+    // Build contact tiers dynamically
+    const tierLines = [];
+    const byTier = { T1: [], T2: [], T3: [], T4: [] };
+    for (const c of profile.topContacts)
+        byTier[c.tier].push(c.name);
+    if (byTier.T1.length)
+        tierLines.push(`T1 (always make time): ${byTier.T1.join(', ')}`);
+    if (byTier.T2.length)
+        tierLines.push(`T2 (high priority): ${byTier.T2.join(', ')}`);
+    if (byTier.T3.length)
+        tierLines.push(`T3 (respond same-day): ${byTier.T3.join(', ')}`);
+    if (byTier.T4.length)
+        tierLines.push(`T4 (respond when free): ${byTier.T4.join(', ')}`);
+    const contactSection = tierLines.length > 0
+        ? `\nINNER CIRCLE (relationship tier → how much prep you do):\n${tierLines.join('\n')}`
+        : '';
+    const projectSection = profile.projects.length > 0
+        ? `\n- Active projects: ${profile.projects.join(', ')}`
+        : '';
+    return `You are ${name}'s chief of staff. You don't brief them — you HANDLE things and present decisions.
+
+THE STANDARD: For every item you produce, ask: "Did I do the work, or am I asking ${name} to do the work?" If the answer is the second one, DO THE WORK FIRST. Their reply to any item should be: yes, no, or a 5-word correction.
+
+WHO ${name.toUpperCase()} IS:
+- Uses iMessage as primary communication${projectSection}
+${contactSection}
+
+═══ EXECUTOR PROTOCOL ═══
+
+STAGE 1: SCAN
+- Call scan_sources, get_unanswered_messages, get_screen_time(days=1), get_browsing(searches_only=true), get_calls(missed_only=true)
+
+STAGE 2: CHASE CONTEXT
+- Every reference to plans, events, people, dates, money → CHASE IT DOWN
+- Use search_all_messages with keyword variations: ["thursday","thurs","tmrw","tomorrow","this week","dinner","drinks","venmo","zelle","split","pay","owe"]
+- Cross-reference across ALL conversations
+
+STAGE 3: DISPATCH WORKERS
+- Workers don't just validate — they DO THE WORK:
+  * Draft reply messages (exact text ${name} can send)
+  * Research options (flights, restaurants, venues — present top 3)
+  * Calculate money owed (exact amounts, who owes whom)
+  * Build timelines (what's happening when, conflicts)
+  * Triage: determine if something needs ${name}'s attention or can be handled silently
+- Spawn 3-5 workers per batch
+- ALWAYS include search_all_messages, get_conversation, profile_contact in worker tools
+
+STAGE 4: SYNTHESIZE INTO DECISIONS
+- Turn worker reports into DECISIONS, not observations
+- Every item = something ${name} can say yes/no to in 5 seconds
+- Include drafted replies they can send as-is
+- Cap: max 3 right_now, max 4 today, max 3 this_week
+
+═══ WHAT TO NEVER DO ═══
+- NEVER narrate data back ("You spent 3 hours on Instagram")
+- NEVER give wellness advice ("Remember to take breaks")
+- NEVER hedge ("Maybe consider", "You might want to", "If you're thinking about")
+- NEVER list things without doing the prep work first
+- NEVER include reactions (Loved, Liked, Laughed at) — they're not messages
+- NEVER include unvalidated predictions
+- NEVER produce more than 10 total items across all sections
+- NEVER assume a message in a group chat is for ${name} — re-read the thread to determine who's being addressed. If two people are coordinating with each other and ${name} just introduced them, that's NOT ${name}'s action item. Wrong attribution = embarrassing draft reply = trust destroyed.
+
+═══ WHAT TO ALWAYS DO ═══
+- Draft the reply text when telling them to respond to someone
+- Include exact amounts for money items
+- Include exact times/venues for plans
+- Use relationship tier to decide urgency (T1 = interrupt them, T4 = batch for later)
+- Present decisions, not todo lists
+- If something can be handled without their input, just note it in "handled"
+
+═══ INTERACTIVE QUESTIONS ═══
+Use ask_user when you need input that can't be derived from data:
+- First run: ask about work focus, key relationships the data might miss, preferences
+- Plan proposals: present 2-3 concrete options for the user to pick from
+- Ambiguity: when data suggests multiple interpretations, ask rather than guess
+The user answers in a separate terminal (auq TUI). Keep questions focused — max 3 per call.
+${delta ? '\n' + delta : ''}${todos ? '\n' + todos : ''}`;
+}
+function buildWorkerSystem() {
+    const name = getUserName();
+    return `You are an execution worker for ${name}'s chief of staff system. You don't just investigate — you DO THE WORK so ${name} only has to say yes or no.
+
+YOUR JOB: Investigate the task, then produce READY-TO-USE output. Not suggestions. Not recommendations. Actual drafts, calculations, timelines.
+
+INVESTIGATION RULES:
+- Be THOROUGH. Search for related keywords across ALL conversations, not just one thread.
+- Chase context: "Thursday" → also search "thurs", "th night", "tmrw", "tomorrow"
+- Profile every person with profile_contact to understand relationship tier and flexibility.
+- Filter out iMessage reactions (Loved, Liked, etc.) — NOT real messages.
+- Cross-reference: check if multiple people discuss the same event/plan.
+
+EXECUTION RULES:
+- If the task involves a message that needs a reply: DRAFT THE EXACT REPLY TEXT ${name} can send.
+- If the task involves plans: produce WHO, WHAT, WHERE, WHEN, WHO'S CONFIRMED.
+- If the task involves money: calculate EXACT amounts owed, by whom, to whom.
+- If the task involves scheduling: identify conflicts with other plans/events.
+- If something doesn't need ${name}'s input: mark it as "can_handle_silently": true.
+
+CRITICAL — GROUP CHAT AWARENESS:
+- Before drafting a reply, determine: is the message ADDRESSED TO ${name}, or are they just in the chat?
+- If ${name} introduced two people and they're now coordinating with each other, that's NOT ${name}'s item.
+- Read the full thread context. Check who is replying to whom. If unsure, mark can_handle_silently: true and explain why in findings.
+- A wrong draft reply that ${name} sends to the wrong person destroys all trust. When in doubt, skip it.
+
+Report as JSON:
+- "validated": true/false
+- "findings": "What you found, with specific quotes and timestamps"
+- "urgency": "critical" | "important" | "low" | "none"
+- "tier": "T1" | "T2" | "T3" | "T4" | "team"
+- "title": "Short decision card title, e.g. 'Caro texted — she just landed'"
+- "options": [
+    { "label": "Recommended action", "description": "What happens — include draft reply text in description if applicable" },
+    { "label": "Alternative", "description": "What this means" },
+    { "label": "Skip/Defer", "description": "Why this is ok to skip" }
+  ]
+- "can_handle_silently": true/false
+- "fyi_context": "If can_handle_silently, brief explanation for the FYI line"
+
+OPTION RULES:
+- Always 2-3 options. Never 1, never 4+.
+- First option = your recommendation. Make it the one you'd pick if you were them.
+- Each option must be a COMPLETE action they're approving, not a vague direction.
+- Include draft reply text in the description when the action involves sending a message.
+- Last option can be "Skip" or "Defer" with a reason why it's ok.`;
+}
+// ─── Worker execution ────────────────────────────────────────────
+async function runWorker(client, task, toolNames, workerId, progress) {
+    const availableTools = TOOLS.filter(t => toolNames.includes(t.name));
+    const toolSchemas = availableTools.map(t => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters,
+    }));
+    const messages = [
+        { role: 'user', content: task },
+    ];
+    for (let turn = 0; turn < MAX_WORKER_TURNS; turn++) {
+        const response = await client.messages.create({
+            model: WORKER_MODEL,
+            max_tokens: 4000,
+            system: buildWorkerSystem(),
+            tools: toolSchemas,
+            messages,
+        });
+        const toolUses = response.content.filter((b) => b.type === 'tool_use');
+        const textBlocks = response.content.filter((b) => b.type === 'text');
+        if (toolUses.length > 0) {
+            messages.push({ role: 'assistant', content: response.content });
+            const toolResults = [];
+            for (const tu of toolUses) {
+                progress?.workerTool(workerId, tu.name);
+                const result = truncateResult(await executeTool(tu.name, (tu.input || {})));
+                toolResults.push({ type: 'tool_result', tool_use_id: tu.id, content: result });
+            }
+            messages.push({ role: 'user', content: toolResults });
+            continue;
+        }
+        if (textBlocks.length > 0) {
+            return textBlocks.map(b => b.text).join('\n');
+        }
+        break;
+    }
+    return '{"validated": false, "findings": "Worker could not complete investigation"}';
+}
+// ─── Orchestrator ────────────────────────────────────────────────
+// Build the spawn_worker tool for the orchestrator
+const SPAWN_WORKER_TOOL = {
+    name: 'spawn_worker',
+    description: `Spawn an execution worker to DO THE WORK on a specific item. Workers investigate AND produce ready-to-use output (draft replies, calculations, timelines).
+
+Workers EXECUTE:
+- Draft exact reply messages the user can send as-is
+- Calculate money owed (exact amounts, who→whom)
+- Build plan timelines (who/what/where/when/confirmed)
+- Profile contacts to determine urgency tier and flexibility
+- Triage items as handle-silently vs needs-decision
+- Cross-reference across data sources
+
+Available tools: scan_sources, get_messages, get_unanswered_messages, get_calls, get_screen_time, get_browsing, get_email_summary, get_git_activity, get_recent_files, get_shell_history, get_notes, get_claude_history, lookup_contact, search_all_messages, profile_contact, get_interests_for_plans, get_conversation`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            task: {
+                type: 'string',
+                description: 'Specific task for the worker. Be detailed about what to investigate and what prediction to validate. Example: "Read the conversation with Adly Azim from the last 2 days. Profile the relationship. Determine if his last message needs an urgent reply or if it\'s casual banter."'
+            },
+            tools: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'List of tool names the worker should have access to. Only give tools relevant to the task.'
+            },
+        },
+        required: ['task', 'tools'],
+    },
+};
+const ASK_USER_TOOL = {
+    name: 'ask_user',
+    description: `Ask the user interactive questions via the AUQ terminal UI. Use when you need input that can't be derived from data: onboarding preferences, choosing between plan options, clarifying ambiguity. The user answers in a separate terminal running \`auq\`. Max 3 questions per call.`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            questions: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        prompt: { type: 'string', description: 'The question to ask.' },
+                        title: { type: 'string', description: 'Short label (max 12 chars).' },
+                        options: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: { label: { type: 'string' }, description: { type: 'string' } },
+                                required: ['label'],
+                            },
+                        },
+                        multiSelect: { type: 'boolean' },
+                    },
+                    required: ['prompt', 'title', 'options'],
+                },
+            },
+        },
+        required: ['questions'],
+    },
+};
+export async function runAgent(apiKey, progress, onCard) {
+    const client = new Anthropic({ apiKey });
+    const name = getUserName();
+    let cardQueue = Promise.resolve(undefined);
+    const directTools = TOOLS.map(t => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters,
+    }));
+    const allTools = [...directTools, SPAWN_WORKER_TOOL, ASK_USER_TOOL];
+    const messages = [
+        { role: 'user', content: `Run the executor protocol. Investigate, do the prep work, present decisions.
+
+1. SCAN: scan_sources, get_unanswered_messages, get_screen_time(days=1), get_browsing(searches_only=true), get_calls(missed_only=true)
+
+2. CHASE CONTEXT: Search for every plan, event, date, money reference across all conversations.
+
+3. DISPATCH WORKERS: For each item that needs attention, spawn a worker to DO THE WORK — draft replies, calculate amounts, build timelines, research options.
+
+4. SYNTHESIZE INTO DECISION CARDS: Every item is a card with 2-3 options ${name} picks from. They should reply in under 60 seconds.
+
+Output format (JSON only, no markdown, no code fences):
+{
+  "greeting": "One sentence. Warm but not sappy.",
+  "handled": ["Things you triaged that don't need their input — just FYI"],
+  "decisions": [
+    {
+      "title": "Short title — who/what, e.g. 'Caro texted — she just landed'",
+      "urgency": "now | today | this_week",
+      "options": [
+        { "label": "Recommended action", "description": "What happens if picked — include draft text for replies" },
+        { "label": "Alternative", "description": "What this means" },
+        { "label": "Skip/Defer", "description": "Why it's ok to skip" }
+      ]
+    },
+    {
+      "title": "FYI — Lexi + Jake connected for Thursday lunch",
+      "urgency": "today",
+      "fyi": true,
+      "context": "Your intro worked, they're coordinating directly. No action."
+    }
+  ],
+  "upcoming": ["Calendar items, deadlines, commitments for the next 7 days with dates/times"],
+  "intel": ["Only novel cross-source patterns worth knowing — no screen time narration, no wellness advice"],
+  "resolved_todos": ["id1", "id2"]
+}
+
+resolved_todos: IDs of open todo items from previous runs that you have evidence are now done (message sent, event passed, etc.). Only include IDs you are confident about.
+
+DECISION CARD RULES:
+- 2-3 options per card. NEVER 1, NEVER 4+. Force yourself to pick the best options.
+- First option = YOUR RECOMMENDATION. If ${name} is in a rush they'll pick all option 1s.
+- Each option is a COMPLETE ACTION they're approving, not a vague direction. "Research clinics" = bad. "Booked consult with Dr. Park Thursday 2pm — confirm?" = good.
+- Include DRAFT REPLY TEXT in the description when the action is sending a message.
+- FYI items (fyi: true) have no options — just a title + context. Use for things they should know about but don't need to act on.
+
+HIGH-LEVERAGE DECISIONS you must make before including an item:
+- "Is this message actually for ${name}, or are they just CC'd / in a group chat?" → If unsure, re-read the thread. If still unsure, don't include it.
+- "Is this urgent or just recent?" → Social message from 10 min ago ≠ urgent. Bill due tomorrow IS urgent even if email came 4 days ago.
+- "Should this be in the briefing at all?" → No action + no insight = cut it. Shorter briefing = they read it.
+- Every wrong item costs trust in the right ones.
+
+CAPS: max 5 handled, max 6 decisions, max 4 upcoming, max 2 intel. Total ≤ 15 items. Less is more.` },
+    ];
+    for (let turn = 0; turn < MAX_ORCHESTRATOR_TURNS; turn++) {
+        progress?.thinking();
+        const response = await client.messages.create({
+            model: ORCHESTRATOR_MODEL,
+            max_tokens: 8000,
+            system: buildOrchestratorPrompt(),
+            tools: allTools,
+            messages,
+        });
+        const toolUses = response.content.filter((b) => b.type === 'tool_use');
+        const textBlocks = response.content.filter((b) => b.type === 'text');
+        if (toolUses.length > 0) {
+            messages.push({ role: 'assistant', content: response.content });
+            // Separate workers, ask_user, and direct tools
+            const workerTUs = toolUses.filter(tu => tu.name === 'spawn_worker');
+            const askTUs = toolUses.filter(tu => tu.name === 'ask_user');
+            const directTUs = toolUses.filter(tu => tu.name !== 'spawn_worker' && tu.name !== 'ask_user');
+            // Run direct tools in parallel
+            const directPromises = directTUs.map(async (tu) => {
+                progress?.toolStart(tu.name);
+                const result = truncateResult(await executeTool(tu.name, (tu.input || {})));
+                progress?.toolDone(tu.name);
+                return { type: 'tool_result', tool_use_id: tu.id, content: result };
+            });
+            // Handle ask_user via AUQ session protocol (user answers in `auq` TUI)
+            const askPromises = askTUs.map(async (tu) => {
+                const input = tu.input;
+                progress?.toolStart('ask_user');
+                const result = await ask(input.questions || []);
+                progress?.toolDone('ask_user');
+                return { type: 'tool_result', tool_use_id: tu.id, content: result };
+            });
+            // Run ALL workers in parallel — stream decision cards as each completes
+            const workerPromises = workerTUs.map(async (tu) => {
+                const input = tu.input;
+                const label = input.task.split(/[.!\n]/)[0]
+                    .replace(/^(PRIORITY|TASK|INVESTIGATE|CHECK|VERIFY):?\s*/i, '')
+                    .slice(0, 48);
+                progress?.workerStart(tu.id, label);
+                try {
+                    let result = truncateResult(await runWorker(client, input.task, input.tools, tu.id, progress), MAX_WORKER_RESULT_LEN);
+                    progress?.workerDone(tu.id);
+                    // Stream card to user as soon as this worker finishes
+                    if (onCard) {
+                        try {
+                            const parsed = JSON.parse(result);
+                            if (parsed.validated && parsed.title) {
+                                const uMap = { critical: 'now', important: 'today', low: 'this_week', none: 'today' };
+                                const card = {
+                                    title: parsed.title,
+                                    urgency: uMap[parsed.urgency] || 'today',
+                                    options: parsed.can_handle_silently ? undefined : parsed.options,
+                                    fyi: !!parsed.can_handle_silently,
+                                    context: parsed.fyi_context || undefined,
+                                };
+                                // Queue card presentation (serialized so prompts don't overlap)
+                                const pick = await new Promise(resolve => {
+                                    cardQueue = cardQueue.then(async () => {
+                                        progress?.pause();
+                                        const p = await onCard(card);
+                                        progress?.resume();
+                                        resolve(p);
+                                    });
+                                });
+                                result += `\nUser's decision: ${pick}`;
+                            }
+                        }
+                        catch { } // parse fail — pass raw result to orchestrator
+                    }
+                    return { type: 'tool_result', tool_use_id: tu.id, content: result };
+                }
+                catch (e) {
+                    progress?.workerFail(tu.id);
+                    return {
+                        type: 'tool_result', tool_use_id: tu.id,
+                        content: `Worker failed: ${String(e)}`, is_error: true,
+                    };
+                }
+            });
+            // Wait for everything in parallel
+            const allResults = await Promise.all([...directPromises, ...askPromises, ...workerPromises]);
+            messages.push({
+                role: 'user',
+                content: allResults,
+            });
+            continue;
+        }
+        // No tools — orchestrator is done
+        if (textBlocks.length > 0) {
+            const content = textBlocks.map(b => b.text).join('\n');
+            const cleaned = content.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+            try {
+                return JSON.parse(cleaned);
+            }
+            catch {
+                const jsonMatch = cleaned.match(/\{[\s\S]*"greeting"[\s\S]*"decisions"[\s\S]*\}/);
+                if (jsonMatch) {
+                    try {
+                        return JSON.parse(jsonMatch[0]);
+                    }
+                    catch { }
+                }
+                return {
+                    greeting: cleaned.slice(0, 300),
+                    handled: [], decisions: [], upcoming: [], intel: [],
+                };
+            }
+        }
+        break;
+    }
+    return {
+        greeting: 'Agent investigation completed but could not produce final analysis.',
+        handled: [], decisions: [], upcoming: [], intel: [],
+    };
+}

package/dist/analyze.d.ts

@@ -0,0 +1,28 @@
+/**
+ * LLM-powered analysis. Sends collected data → gets back a personal briefing.
+ */
+export type DecisionOption = {
+    label: string;
+    description: string;
+};
+export type Decision = {
+    title: string;
+    urgency: 'now' | 'today' | 'this_week';
+    options?: DecisionOption[];
+    fyi?: boolean;
+    context?: string;
+};
+export type Analysis = {
+    greeting: string;
+    handled?: string[];
+    decisions?: Decision[];
+    upcoming?: string[];
+    intel?: string[];
+    resolved_todos?: string[];
+    right_now?: string[];
+    today?: string[];
+    this_week?: string[];
+    noticed?: string[];
+    heads_up?: string[];
+};
+export declare function analyzeWithLLM(collectedData: Record<string, unknown>, apiKey: string): Promise<Analysis>;

package/dist/analyze.js

@@ -0,0 +1,130 @@
+/**
+ * LLM-powered analysis. Sends collected data → gets back a personal briefing.
+ */
+import { buildDeltaContext } from './state.js';
+import { getUserName, buildProfile } from './profile.js';
+const API_URL = 'https://openrouter.ai/api/v1/chat/completions';
+const MODEL = 'google/gemini-2.5-flash';
+function buildPersona() {
+    const profile = buildProfile();
+    const name = profile.name;
+    const lines = [`WHO YOU'RE BRIEFING:\n${name}.`];
+    if (profile.topContacts.length > 0) {
+        lines.push(`\n${name.toUpperCase()}'S KEY CONTACTS (auto-detected by message volume, last 30 days):`);
+        const byTier = { T1: [], T2: [], T3: [], T4: [] };
+        for (const c of profile.topContacts) {
+            byTier[c.tier].push(`${c.name} (${c.msgs30d} msgs)`);
+        }
+        if (byTier.T1.length)
+            lines.push(`- Inner circle (very high volume): ${byTier.T1.join(', ')}`);
+        if (byTier.T2.length)
+            lines.push(`- Close contacts: ${byTier.T2.join(', ')}`);
+        if (byTier.T3.length)
+            lines.push(`- Regular contacts: ${byTier.T3.join(', ')}`);
+        if (byTier.T4.length)
+            lines.push(`- Occasional contacts: ${byTier.T4.join(', ')}`);
+    }
+    if (profile.projects.length > 0) {
+        lines.push(`\nACTIVE PROJECTS: ${profile.projects.join(', ')}`);
+    }
+    return lines.join('\n');
+}
+function buildSystemPrompt() {
+    const name = getUserName();
+    return `You are ${name}'s telepathic executive assistant. You know them better than they know themselves. You have access to 30 days of their digital life.
+
+${buildPersona()}
+
+YOUR DATA SOURCES (what you're looking at):
+- iMessage conversations (full threads with timestamps)
+- Phone call history (who, when, duration)
+- Calendar events (upcoming commitments)
+- Screen time (app usage, categories, daily totals)
+- Safari + Chrome browsing history (URLs, search queries, timestamps)
+- Shell/terminal history (commands run, what's being built)
+- Apple Mail
+- Apple Notes
+- Notifications
+- Recently opened files
+- Find My (device locations)
+- Installed applications
+
+RULES:
+- ALWAYS use people's NAMES. You know who everyone is. Never show phone numbers or handles.
+- Be INSANELY specific. Not "respond to messages" but "Text [name] back about dinner — they asked you yesterday."
+- EXPONENTIAL TIME WEIGHTING: Last 24 hours = CRITICAL. Last 7 days = important context. Last 30 days = background patterns. Weight urgency accordingly.
+- Cross-reference EVERYTHING. Searches reveal thinking. Browsing reveals research. Messages reveal commitments. Screen time reveals where attention actually goes. Shell history reveals what's being built and what's broken.
+- Use the contact tier data to prioritize — inner circle contacts get immediate attention, occasional contacts can wait.
+- ONLY surface things you're CERTAIN about from the data. Wrong suggestions = you get turned off. Accuracy > coverage.
+- No counting. No statistics. No "you sent X messages." They care about WHAT needs doing, not HOW MUCH was done.
+- No generic advice. No "consider" or "you might want to." If something needs doing, say DO IT.
+- Talk like a trusted friend with perfect memory. Not a report generator.
+- Surface contradictions: researching sleep but browsing at 2am? Say it.
+- Don't moralize about screen time or social media.
+
+OUTPUT FORMAT — return ONLY this JSON (no markdown, no code fences):
+{
+  "greeting": "One sentence. What their last day/week has been like, in plain human language.",
+  "right_now": [
+    "Most urgent action with specific names and context — things from the last 24 hours that need immediate attention"
+  ],
+  "today": [
+    "Things to handle today — messages to respond to, follow-ups, commitments"
+  ],
+  "this_week": [
+    "Things from the broader week/month that shouldn't be forgotten"
+  ],
+  "heads_up": [
+    "Upcoming commitments, follow-ups promised, things from group chats that might be forgotten"
+  ],
+  "noticed": [
+    "Patterns you noticed — health, relationships, work habits, the stuff a great EA would whisper. Only say things you're CONFIDENT about from the data."
+  ]
+}`;
+}
+export async function analyzeWithLLM(collectedData, apiKey) {
+    const contextStr = JSON.stringify(collectedData, null, 1);
+    const trimmed = contextStr.length > 200_000
+        ? contextStr.slice(0, 200_000) + '\n...(truncated)'
+        : contextStr;
+    const deltaContext = buildDeltaContext();
+    const name = getUserName();
+    const userContent = `Analyze ${name}'s life right now. Tell them exactly what to do, starting with the most urgent.
+
+Data from the last 30 days (most recent first — prioritize accordingly):
+
+${trimmed}${deltaContext ? '\n\n' + deltaContext : ''}`;
+    const response = await fetch(API_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            model: MODEL,
+            messages: [
+                { role: 'system', content: buildSystemPrompt() },
+                { role: 'user', content: userContent }
+            ],
+            temperature: 0.3,
+            max_tokens: 4000,
+        })
+    });
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`API error ${response.status}: ${err}`);
+    }
+    const json = await response.json();
+    const content = json.choices?.[0]?.message?.content || '';
+    const cleaned = content.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch {
+        return {
+            greeting: content.slice(0, 300),
+            right_now: [], today: [], this_week: [],
+            noticed: [], heads_up: []
+        };
+    }
+}

package/dist/auq.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Lightweight AUQ session protocol client.
+ * Speaks the same file protocol as auq-mcp-server so the `auq` TUI picks up questions.
+ */
+export interface AuqQuestion {
+    prompt: string;
+    title: string;
+    options: {
+        label: string;
+        description?: string;
+    }[];
+    multiSelect?: boolean;
+}
+export declare function createSession(questions: AuqQuestion[]): string;
+export declare function ask(questions: AuqQuestion[], timeoutMs?: number): Promise<string>;