@conversionpros/aiva 1.0.0

package/diagnostics-api.js

@@ -0,0 +1,304 @@
+/**
+ * AIVA Remote Diagnostics API
+ * Port 3850 — exposes device health, logs, errors, system info
+ * Authenticated via DIAG_TOKEN (Bearer token), except /health
+ */
+
+const http = require('http');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const url = require('url');
+
+const PORT = 3850;
+const DIAG_TOKEN = process.env.DIAG_TOKEN || '5f734d1d83211f8fff8f21b53e1c42d9bc27ad7bd47ae1ebc9b72fd9ef3c9281';
+const HOME = os.homedir();
+const AIVA_DIR = path.join(HOME, '.openclaw', 'workspace', 'aiva-tasks');
+const startTime = Date.now();
+
+// --- Helpers ---
+
+function readLastLines(filePath, n = 100) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    return lines.slice(-n).join('\n');
+  } catch (e) {
+    return null;
+  }
+}
+
+function sendJSON(res, statusCode, data) {
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Headers': 'Authorization, Content-Type',
+  });
+  res.end(JSON.stringify(data));
+}
+
+function authenticate(req) {
+  const auth = req.headers['authorization'];
+  if (!auth || !auth.startsWith('Bearer ')) return false;
+  return auth.slice(7) === DIAG_TOKEN;
+}
+
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', timeout: 10000 }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// --- Route Handlers ---
+
+function handleHealth(req, res) {
+  sendJSON(res, 200, {
+    status: 'ok',
+    uptime: Math.floor((Date.now() - startTime) / 1000),
+    hostname: os.hostname(),
+    timestamp: new Date().toISOString(),
+  });
+}
+
+function handleLogs(req, res, query) {
+  const lines = parseInt(query.lines) || 100;
+  const type = query.type || 'out'; // out | err
+
+  // Try PM2 logs first
+  const pm2LogDir = path.join(HOME, '.pm2', 'logs');
+  const suffix = type === 'err' ? 'error' : 'out';
+  const pm2File = path.join(pm2LogDir, `aiva-app-${suffix}.log`);
+
+  let content = readLastLines(pm2File, lines);
+  let source = 'pm2';
+
+  if (!content) {
+    // Try LaunchAgent logs
+    const laFile = type === 'err'
+      ? path.join(HOME, 'Library', 'Logs', 'aiva-app-stderr.log')
+      : path.join(HOME, 'Library', 'Logs', 'aiva-app-stdout.log');
+    content = readLastLines(laFile, lines);
+    source = 'launchagent';
+  }
+
+  sendJSON(res, 200, {
+    source,
+    type,
+    lines: lines,
+    content: content || 'No log file found',
+  });
+}
+
+function handleErrors(req, res) {
+  // Parse PM2 error log and out log for error patterns
+  const logFiles = [
+    path.join(HOME, '.pm2', 'logs', 'aiva-app-error.log'),
+    path.join(HOME, '.pm2', 'logs', 'aiva-app-out.log'),
+  ];
+
+  const errorPattern = /error|Error|ERROR|TypeError|ReferenceError|SyntaxError|ENOENT|ECONNREFUSED|UnhandledPromise|stack trace/i;
+  const now = Date.now();
+  const buckets = { '1h': 0, '6h': 0, '24h': 0 };
+  const recentErrors = [];
+
+  for (const file of logFiles) {
+    let content;
+    try {
+      content = fs.readFileSync(file, 'utf8');
+    } catch { continue; }
+
+    const lines = content.split('\n');
+    for (const line of lines) {
+      if (!errorPattern.test(line)) continue;
+
+      // Try to extract timestamp - PM2 logs often have ISO timestamps
+      const tsMatch = line.match(/(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2})/);
+      if (tsMatch) {
+        const ts = new Date(tsMatch[1]).getTime();
+        if (isNaN(ts)) continue;
+        const age = now - ts;
+        if (age < 3600000) buckets['1h']++;
+        if (age < 21600000) buckets['6h']++;
+        if (age < 86400000) buckets['24h']++;
+        if (age < 3600000 && recentErrors.length < 20) {
+          recentErrors.push(line.trim().slice(0, 200));
+        }
+      } else {
+        // No timestamp - count in 24h bucket
+        buckets['24h']++;
+      }
+    }
+  }
+
+  sendJSON(res, 200, { buckets, recentErrors });
+}
+
+function handleSystem(req, res) {
+  const cpus = os.cpus();
+  const loadAvg = os.loadavg();
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+
+  // macOS version
+  const macVersion = safeExec('sw_vers -productVersion') || 'unknown';
+  const nodeVersion = process.version;
+
+  // Disk usage
+  let disk = null;
+  const dfOut = safeExec("df -h / | tail -1");
+  if (dfOut) {
+    const parts = dfOut.split(/\s+/);
+    disk = { total: parts[1], used: parts[2], available: parts[3], pctUsed: parts[4] };
+  }
+
+  // Tailscale IP
+  const tailscaleIP = safeExec('tailscale ip -4') || null;
+
+  // Network interfaces (simplified)
+  const nets = os.networkInterfaces();
+  const interfaces = {};
+  for (const [name, addrs] of Object.entries(nets)) {
+    interfaces[name] = addrs
+      .filter(a => !a.internal)
+      .map(a => ({ address: a.address, family: a.family }));
+  }
+
+  sendJSON(res, 200, {
+    hostname: os.hostname(),
+    platform: os.platform(),
+    arch: os.arch(),
+    macVersion,
+    nodeVersion,
+    uptime: os.uptime(),
+    cpuCount: cpus.length,
+    cpuModel: cpus[0]?.model,
+    loadAvg: { '1m': loadAvg[0], '5m': loadAvg[1], '15m': loadAvg[2] },
+    memory: {
+      total: totalMem,
+      free: freeMem,
+      used: totalMem - freeMem,
+      pctUsed: ((1 - freeMem / totalMem) * 100).toFixed(1) + '%',
+    },
+    disk,
+    tailscaleIP,
+    interfaces,
+  });
+}
+
+function handleProcesses(req, res) {
+  const processNames = ['aiva-app', 'auto-deploy', 'health-reporter', 'diagnostics-api'];
+  const results = [];
+
+  // Try PM2 first
+  const pm2Json = safeExec('pm2 jlist 2>/dev/null');
+  let pm2Processes = [];
+  if (pm2Json) {
+    try { pm2Processes = JSON.parse(pm2Json); } catch {}
+  }
+
+  for (const name of processNames) {
+    const pm2Proc = pm2Processes.find(p => p.name === name);
+    if (pm2Proc) {
+      results.push({
+        name,
+        manager: 'pm2',
+        status: pm2Proc.pm2_env?.status || 'unknown',
+        pid: pm2Proc.pid,
+        uptime: pm2Proc.pm2_env?.pm_uptime ? Date.now() - pm2Proc.pm2_env.pm_uptime : null,
+        restarts: pm2Proc.pm2_env?.restart_time || 0,
+        memory: pm2Proc.monit?.memory || null,
+        cpu: pm2Proc.monit?.cpu || null,
+      });
+    } else {
+      // Check if running as regular process
+      const pid = safeExec(`pgrep -f "${name}" 2>/dev/null`);
+      results.push({
+        name,
+        manager: pid ? 'system' : 'none',
+        status: pid ? 'online' : 'stopped',
+        pid: pid ? parseInt(pid.split('\n')[0]) : null,
+        uptime: null,
+        restarts: null,
+      });
+    }
+  }
+
+  sendJSON(res, 200, { processes: results });
+}
+
+function handleConfig(req, res) {
+  const envFile = path.join(AIVA_DIR, '.env');
+  try {
+    const content = fs.readFileSync(envFile, 'utf8');
+    const masked = content.split('\n').map(line => {
+      if (!line.includes('=') || line.startsWith('#')) return line;
+      const eqIdx = line.indexOf('=');
+      const key = line.slice(0, eqIdx);
+      return `${key}=***`;
+    }).join('\n');
+    sendJSON(res, 200, { config: masked });
+  } catch {
+    sendJSON(res, 200, { config: 'No .env file found' });
+  }
+}
+
+function handleDeployLog(req, res) {
+  const logFile = path.join(AIVA_DIR, 'data', 'auto-deploy.log');
+  const content = readLastLines(logFile, 50);
+  sendJSON(res, 200, { log: content || 'No deploy log found' });
+}
+
+// --- Server ---
+
+const server = http.createServer((req, res) => {
+  // CORS preflight
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, OPTIONS',
+      'Access-Control-Allow-Headers': 'Authorization, Content-Type',
+    });
+    return res.end();
+  }
+
+  if (req.method !== 'GET') {
+    return sendJSON(res, 405, { error: 'Method not allowed' });
+  }
+
+  const parsed = url.parse(req.url, true);
+  const pathname = parsed.pathname;
+
+  // /health is unauthenticated
+  if (pathname === '/health') return handleHealth(req, res);
+
+  // All other routes require auth
+  if (!authenticate(req)) {
+    return sendJSON(res, 401, { error: 'Unauthorized — provide valid Bearer token' });
+  }
+
+  try {
+    switch (pathname) {
+      case '/logs': return handleLogs(req, res, parsed.query);
+      case '/errors': return handleErrors(req, res);
+      case '/system': return handleSystem(req, res);
+      case '/processes': return handleProcesses(req, res);
+      case '/config': return handleConfig(req, res);
+      case '/deploy-log': return handleDeployLog(req, res);
+      default: return sendJSON(res, 404, { error: 'Not found' });
+    }
+  } catch (err) {
+    console.error('Handler error:', err);
+    sendJSON(res, 500, { error: 'Internal server error', detail: err.message });
+  }
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught exception:', err);
+});
+
+server.listen(PORT, '0.0.0.0', () => {
+  console.log(`Diagnostics API running on port ${PORT}`);
+});

package/docs/ara-dedup-fix-scope.md

@@ -0,0 +1,112 @@
+# Ara Voice Fix: Duplicate Response Audio Suppression
+
+## File: `voice-call.js`
+
+## Root Cause
+xAI's Realtime API sometimes fires TWO complete response cycles for a single user turn. The current dedup only catches it at `response.done` — but by then the audio has already been streamed to the client via `response.output_audio.delta`. The user hears the same answer twice.
+
+## Fix: Track response IDs and suppress duplicate audio
+
+### Step 1: Add response tracking per call session
+
+In the `callSession` object (wherever it's initialized, look for `callSession = {`), add:
+
+```javascript
+completedResponseTexts: [],  // track completed response texts
+currentResponseId: null,     // track current response ID
+```
+
+### Step 2: Capture response ID on `response.created`
+
+In the `response.created` case, capture the response ID:
+
+```javascript
+case 'response.created':
+  callSession.currentResponseText = '';
+  callSession.currentResponseId = msg.response?.id || null;
+  socket.emit('voice-call-status', { status: 'speaking' });
+  break;
+```
+
+### Step 3: Suppress audio at the delta level
+
+Replace the `response.output_audio.delta` handler:
+
+```javascript
+case 'response.output_audio.delta':
+  if (msg.delta) {
+    // Check if we're in a duplicate response by comparing accumulated text so far
+    // We'll use a flag set during transcript accumulation
+    if (!callSession.suppressCurrentResponse) {
+      socket.emit('voice-call-audio-delta', { audio: msg.delta });
+    }
+  }
+  break;
+```
+
+### Step 4: Detect duplicates during transcript accumulation
+
+Replace the `response.output_audio_transcript.delta` handler:
+
+```javascript
+case 'response.output_audio_transcript.delta':
+  if (msg.delta) {
+    callSession.currentResponseText += msg.delta;
+    // Once we have 50+ chars, check if this matches a previous response
+    if (!callSession.suppressCurrentResponse && callSession.currentResponseText.length >= 50) {
+      const prefix = callSession.currentResponseText.slice(0, 50);
+      if (callSession.completedResponseTexts.some(t => t.slice(0, 50) === prefix)) {
+        callSession.suppressCurrentResponse = true;
+        console.log('[voice-call] Suppressing duplicate response audio');
+      }
+    }
+    if (!callSession.suppressCurrentResponse) {
+      socket.emit('voice-call-transcript-delta', { text: msg.delta });
+    }
+  }
+  break;
+```
+
+### Step 5: Record completed responses and reset
+
+Replace the `response.output_audio_transcript.done` handler:
+
+```javascript
+case 'response.output_audio_transcript.done':
+  if (msg.transcript && !callSession.suppressCurrentResponse) {
+    callSession.transcript.push({ role: 'assistant', text: msg.transcript });
+  }
+  break;
+```
+
+Update the `response.done` handler — remove the old dedup logic and replace with:
+
+```javascript
+case 'response.done': {
+  socket.emit('voice-call-status', { status: 'listening' });
+  const respText = callSession.currentResponseText;
+  if (respText && !callSession.suppressCurrentResponse) {
+    callSession.completedResponseTexts.push(respText);
+    // Keep only last 5 to prevent memory growth
+    if (callSession.completedResponseTexts.length > 5) {
+      callSession.completedResponseTexts.shift();
+    }
+    socket.emit('voice-call-response-done', { text: respText });
+  }
+  // Reset for next response
+  callSession.suppressCurrentResponse = false;
+  break;
+}
+```
+
+### Step 6: Clean up old dedup code
+
+Remove the `lastResponseText` Map (line ~24) and its cleanup on disconnect (line ~711) since we're using per-session tracking now.
+
+## After Changes
+- `pm2 restart aiva-app`
+- Verify started
+
+## IMPORTANT
+- Only modify `voice-call.js`
+- Do NOT touch `public/index.html`

package/docs/ara-fix-round2-scope.md

@@ -0,0 +1,61 @@
+# Ara Voice Fix Round 2: Calendar Tool + Duplicate Responses
+
+## File: `voice-call.js`
+
+## Fix 1: Filter past events in `check_calendar` tool (around line 345-353)
+
+The `check_calendar` tool handler returns ALL events including past ones. Add past-event filtering when `timeframe === 'today'`.
+
+**REPLACE** the calResults return block (around line 352-353):
+
+```javascript
+        // Filter past events for today view
+        if (tf === 'today') {
+          calResults = calResults.filter(line => {
+            const timeMatch = line.match(/(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2})/);
+            if (timeMatch) {
+              const eventTime = new Date(timeMatch[1].replace(' ', 'T'));
+              return eventTime > now;
+            }
+            return true; // keep lines without parseable time
+          });
+        }
+        return { success: true, calendar: calResults.join('\n') || 'No upcoming events today.' };
+```
+
+## Fix 2: Filter past events in `weekCalendar` pre-fetch (around line 87-102)
+
+The week calendar pre-fetch does NOT filter past events. Add the same filter:
+
+After `weekLines.push(...)` and before `result.weekCalendar = weekLines.join('\n')`, add:
+
+```javascript
+      // Filter out past events from this week too
+      weekLines = weekLines.filter(line => {
+        const timeMatch = line.match(/(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2})/);
+        if (timeMatch) {
+          const eventTime = new Date(timeMatch[1].replace(' ', 'T'));
+          return eventTime > now;
+        }
+        return true;
+      });
+```
+
+## Fix 3: Prevent duplicate responses
+
+Look for where `response.audio.done` or `response.done` events trigger sending audio to the client. If there's a risk of duplicate tool-call responses being sent, add a dedup guard. Specifically check if there's a pattern where both a tool result AND a follow-up response trigger separate audio sends for the same content.
+
+If you see a `response.audio.done` handler that doesn't dedup, add a simple guard:
+```javascript
+// Track last response to prevent duplicates
+const lastResponseText = new Map(); // callId -> lastText
+```
+Before sending audio response text, check if it's substantially the same as the last one sent (first 50 chars match). If so, skip it.
+
+## After Changes
+- `pm2 restart aiva-app`
+- Verify started successfully
+
+## IMPORTANT
+- Only modify `voice-call.js`
+- Do NOT touch `public/index.html` or microphone feature

package/docs/ara-greeting-fix-scope.md

@@ -0,0 +1,70 @@
+# Ara Voice Call Fix: Greeting Behavior + Calendar Filtering
+
+## File: `voice-call.js`
+
+## Problem
+1. Ara dumps calendar events immediately on connect before understanding user intent
+2. Calendar context includes past events (e.g., 7:30 AM and 11 AM events mentioned at 2:30 PM)
+
+## Fix 1: System Prompt — Don't Volunteer Info
+
+Change the greeting instruction (around line 147):
+
+**FROM:**
+```
+- Start the conversation with a casual greeting like "Hey! What's up?"
+```
+
+**TO:**
+```
+- Start the conversation with a brief, casual greeting like "Hey Brandon, what's up?" and WAIT for the user to speak. Do NOT volunteer any information (calendar, tasks, etc.) until the user tells you what they need. Your job is to listen first, then assist. Only bring up calendar/tasks/context when the user asks or when it's directly relevant to what they're discussing.
+```
+
+## Fix 2: Filter Past Calendar Events
+
+In `buildSystemPrompt()` where calendar events are appended (around line 163-165), filter out events that have already passed:
+
+**FROM:**
+```javascript
+if (ctx.calendar?.length) {
+  const events = ctx.calendar.slice(0, 5).map(e => `- ${e.title || e.summary} (${e.time || e.start || ''})`).join('\n');
+  prompt += `\n\nToday's calendar:\n${events}`;
+}
+```
+
+**TO:**
+```javascript
+if (ctx.calendar?.length) {
+  const now = new Date();
+  const futureEvents = ctx.calendar.filter(e => {
+    const eventTime = e.time || e.start || '';
+    if (!eventTime) return true; // keep events with no time (all-day)
+    try {
+      const eventDate = new Date(eventTime);
+      return eventDate > now;
+    } catch { return true; }
+  });
+  if (futureEvents.length) {
+    const events = futureEvents.slice(0, 5).map(e => `- ${e.title || e.summary} (${e.time || e.start || ''})`).join('\n');
+    prompt += `\n\nUpcoming calendar events (DO NOT mention these unless asked):\n${events}`;
+  }
+}
+```
+
+Also apply the same past-event filtering to the pre-fetch calendar sections (lines ~55-104) where `todayCalendar` and `weekCalendar` are built.
+
+## Fix 3: Label Context as Reference-Only
+
+Change the calendar/tasks/chat context labels to make it clear they're reference material, not conversation starters:
+
+- `Today's calendar:` → `Upcoming calendar events (reference only — do NOT mention unless asked):`
+- `Active tasks:` → `Active tasks (reference only — do NOT mention unless asked):`
+- `Recent chat:` → `Recent chat context (reference only):`
+
+## After Changes
+- Restart: `pm2 restart aiva-app`
+- Test by calling and confirming Ara greets briefly and waits
+
+## IMPORTANT
+- Do NOT touch the microphone icon (voice-to-text) — only the phone icon voice call feature
+- Do NOT touch `public/index.html` — changes are server-side only in `voice-call.js`

package/docs/calendar-date-fix-scope.md

@@ -0,0 +1,28 @@
+# Calendar Date Parsing Fix — Scope Doc
+
+## Problem
+The `check_calendar` tool in `voice-call.js` uses relative date strings like `+7d` and `+2d` with the `gog calendar list` command, but `gog` doesn't support that syntax. It needs absolute ISO dates (e.g., `2026-02-11`) or keywords like `today`, `tomorrow`, `monday`.
+
+## File
+`/Users/brandonburgan/.openclaw/workspace/aiva-tasks/voice-call.js`
+
+## Fix
+In the `check_calendar` tool handler, replace any relative date logic (`+Xd`) with computed absolute dates using JavaScript's `Date` object.
+
+Example: If `timeframe === 'week'`, compute:
+```js
+const from = new Date().toISOString().split('T')[0]; // today
+const to = new Date(Date.now() + 7 * 86400000).toISOString().split('T')[0]; // 7 days out
+```
+
+Then pass `--from ${from} --to ${to}` to the `gog calendar list` command.
+
+## Specific Changes
+1. Find the `check_calendar` tool handler function
+2. Replace any `+Xd` style date strings with computed absolute dates
+3. Handle all timeframe values: `today`, `tomorrow`, `week`, `month`
+4. Make sure the `--from` flag uses today's date (not a relative string)
+
+## Testing
+After changes, restart PM2: `pm2 restart aiva-app`
+Test by making a voice call and asking "What's on my calendar this week?"

package/docs/getting-started.md

@@ -0,0 +1,115 @@
+# Getting to Know Your AIVA Assistant
+
+Welcome! AIVA (AI Virtual Assistant) is your personal AI-powered assistant designed to help you stay organized, communicate effectively, and get things done. Here's everything you need to know to get the most out of AIVA.
+
+---
+
+## What is AIVA?
+
+AIVA is more than a chatbot — she's a team of specialized AI agents working together behind the scenes. Think of it like having a personal office staff: each agent has a specific role, and they coordinate to handle your requests efficiently.
+
+You don't need to worry about which agent does what — just communicate naturally, and AIVA routes everything to the right place.
+
+---
+
+## How AIVA is Set Up
+
+AIVA uses a **multi-agent system**, meaning different agents handle different types of work:
+
+### Main Agent (Your Central Brain)
+This is the agent you talk to in the **AIVA App**. It's the coordinator — the one that:
+- Receives your requests and figures out who should handle them
+- Manages your task board
+- Distributes knowledge across all other agents
+- Handles calendar, email monitoring, and general questions
+- Sends you morning and evening briefings
+
+**Think of it as your executive assistant** who delegates to specialists.
+
+### Outreach Agent (Your Message Manager)
+This agent handles all **iMessage and text communication**. When someone texts your AIVA-managed number:
+- The outreach agent reads and responds (based on your preferences)
+- It manages conversations with contacts on your behalf
+- It follows up on active conversations automatically
+- It surfaces important messages to the main agent when needed
+
+**Think of it as your receptionist** — fielding calls and messages so you don't have to.
+
+### Email Agent (Your Inbox Manager)
+Monitors your email, triages messages, and alerts you to anything important. Routine stuff gets handled automatically so you only see what matters.
+
+### Research Agent (Your Analyst)
+When you need information — market research, competitor analysis, or deep dives on a topic — the research agent handles it and reports back with findings.
+
+### Content Agent (Your Writer)
+Handles content creation tasks — drafts, copy, documentation, social posts, and more.
+
+---
+
+## How to Communicate with AIVA
+
+### The AIVA App (Your Main Channel)
+The AIVA app is your **central hub**. This is where you should:
+- **Brain dump** — tell AIVA everything on your mind. She'll organize it, create tasks, and distribute knowledge to the right agents.
+- **Make requests** — "Schedule a meeting with John next week" or "Research the best CRM tools for small businesses"
+- **Check your task board** — see what's in progress, what's done, and what needs attention
+- **Review agent activity** — see what your agents are working on
+
+**Pro tip:** Voice messages work great in the app. Just talk naturally — AIVA will transcribe and act on it.
+
+### iMessage (Your Outreach Channel)
+Messages sent to your AIVA phone number go directly to the **outreach agent**. This is specifically for:
+- Managing conversations with contacts
+- Scheduling and follow-ups
+- Having your outreach agent handle communication on your behalf
+
+**Important:** The outreach agent is a separate specialist from your main AIVA. Training it happens through iMessage conversations. The more context you give it about how you want to handle specific contacts, the better it gets.
+
+### What Happens When You Submit a Request
+
+1. **You send a message** (via app, voice, or text)
+2. **AIVA receives it** and creates a task on your board
+3. **The right agent picks it up** based on what needs to be done
+4. **Work happens** — you can check progress on the task board anytime
+5. **You get notified** when it's done, with a summary of what was accomplished
+
+---
+
+## Best Practices
+
+### Do This
+- **Be specific** — "Schedule a 30-min call with John on Thursday at 2 PM" works better than "set something up with John"
+- **Use the app for big-picture stuff** — strategy, planning, brain dumps, complex requests
+- **Use iMessage for message management** — training your outreach agent on how to handle contacts
+- **Check your task board** — it's the single source of truth for all work in progress
+- **Give feedback** — if AIVA does something you don't like, say so. She learns from your preferences.
+
+### Avoid This
+- **Don't repeat yourself** — if you submitted a request, it's on the board. No need to follow up unless it's been too long.
+- **Don't mix channels unnecessarily** — use the app for requests, iMessage for message management
+- **Don't assume AIVA knows everything** — she wakes up fresh each session. Important context should be stated clearly.
+
+---
+
+## Frequently Asked Questions
+
+**Q: Does AIVA remember our conversations?**
+A: AIVA maintains memory through daily notes and long-term memory files. Important decisions, preferences, and context are saved between sessions. However, she starts each session fresh and reads her notes — so the more important something is, the more clearly you should state it.
+
+**Q: Can AIVA text people on my behalf?**
+A: Yes! The outreach agent can handle iMessage conversations. You set preferences for each contact (respond, ignore, take message only), and AIVA follows them. She'll always check with you before contacting someone new.
+
+**Q: How do I know what AIVA is working on?**
+A: Check the task board in the app. Every request becomes a task with status tracking (To Do, In Progress, Done).
+
+**Q: What if AIVA makes a mistake?**
+A: Tell her! Feedback helps AIVA improve. She logs lessons learned and adjusts her approach going forward.
+
+**Q: Is my information private?**
+A: Yes. AIVA treats your data with strict privacy. She won't share personal information in group settings or with other contacts without your explicit permission.
+
+---
+
+## Updates
+
+*Check the Updates page for the latest changes and improvements to your AIVA assistant.*