create-walle 0.1.0

package/template/wall-e/skills/_bundled/google-calendar/run.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * google-calendar sync skill — reads events from macOS Calendar (which syncs
+ * with Google Calendar) via a compiled Swift binary using EventKit, then
+ * stores them as memories in WALL-E's brain.
+ *
+ * Usage:  node run.js [--days-back N] [--days-ahead N]
+ *
+ * Requires: Calendar access granted to the terminal in
+ *   System Settings > Privacy & Security > Calendars
+ */
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const SKILL_DIR = __dirname;
+const SWIFT_SRC = path.join(SKILL_DIR, 'cal-reader.swift');
+const BINARY = path.join(SKILL_DIR, 'cal-reader');
+
+// Parse CLI args
+const args = process.argv.slice(2);
+let daysBack = 1;
+let daysAhead = 14;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--days-back' && args[i + 1]) daysBack = parseInt(args[i + 1], 10);
+  if (args[i] === '--days-ahead' && args[i + 1]) daysAhead = parseInt(args[i + 1], 10);
+}
+
+// ── Step 1: Compile Swift binary if needed ───────────────────────────
+
+function ensureBinary() {
+  const srcStat = fs.statSync(SWIFT_SRC);
+  let needCompile = true;
+  if (fs.existsSync(BINARY)) {
+    const binStat = fs.statSync(BINARY);
+    needCompile = srcStat.mtimeMs > binStat.mtimeMs;
+  }
+  if (needCompile) {
+    console.error('[calendar-sync] Compiling cal-reader.swift...');
+    execFileSync('swiftc', ['-O', SWIFT_SRC, '-o', BINARY, '-framework', 'EventKit'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 120_000,
+    });
+    console.error('[calendar-sync] Compiled successfully');
+  }
+}
+
+// ── Step 2: Read events from macOS Calendar ──────────────────────────
+
+function readEvents() {
+  const result = execFileSync(BINARY, [
+    '--days-back', String(daysBack),
+    '--days-ahead', String(daysAhead),
+  ], { timeout: 30_000, maxBuffer: 10 * 1024 * 1024 });
+
+  const events = JSON.parse(result.toString('utf8'));
+  console.error(`[calendar-sync] Read ${events.length} events (${daysBack}d back, ${daysAhead}d ahead)`);
+  return events;
+}
+
+// ── Step 3: Store in brain ───────────────────────────────────────────
+
+function storeToBrain(events) {
+  const brainPath = path.resolve(SKILL_DIR, '..', '..', '..', 'brain.js');
+  if (!fs.existsSync(brainPath)) {
+    console.error(`[calendar-sync] brain.js not found at ${brainPath}`);
+    process.exit(1);
+  }
+  const brain = require(brainPath);
+  brain.initDb();
+
+  let inserted = 0;
+  let skipped = 0;
+  let updated = 0;
+
+  for (const evt of events) {
+    // Build a readable content string
+    const parts = [evt.title];
+    if (evt.location) parts.push(`Location: ${evt.location}`);
+    if (evt.attendees && evt.attendees.length > 0) {
+      const names = evt.attendees.map(a => a.name || a.email).filter(Boolean);
+      if (names.length > 0) parts.push(`Attendees: ${names.join(', ')}`);
+    }
+    if (evt.organizer) parts.push(`Organizer: ${evt.organizer}`);
+    if (evt.notes) parts.push(`Notes: ${evt.notes}`);
+    const content = parts.join('\n');
+
+    // Use uid + start as source_id for dedup
+    const sourceId = `cal:${evt.uid}:${evt.start}`;
+
+    // Check if this exact event already exists
+    const existing = brain.getDb().prepare(
+      'SELECT id, content FROM memories WHERE source = ? AND source_id = ?'
+    ).get('calendar', sourceId);
+
+    if (existing) {
+      // Update if content changed (attendees added, notes updated, etc.)
+      if (existing.content !== content) {
+        brain.getDb().prepare(
+          'UPDATE memories SET content = ?, metadata = ?, timestamp = ? WHERE id = ?'
+        ).run(content, JSON.stringify(evt), evt.start, existing.id);
+        updated++;
+      } else {
+        skipped++;
+      }
+      continue;
+    }
+
+    // Insert new event
+    const mem = {
+      source: 'calendar',
+      source_id: sourceId,
+      source_channel: evt.calendar,
+      memory_type: evt.allDay ? 'calendar_allday' : 'calendar_event',
+      subject: evt.title,
+      content,
+      metadata: JSON.stringify(evt),
+      importance: evt.allDay ? 0.3 : 0.5,
+      timestamp: evt.start,
+    };
+
+    const result = brain.insertMemory(mem);
+    if (result) inserted++;
+    else skipped++;
+  }
+
+  brain.closeDb();
+  return { inserted, skipped, updated, total: events.length };
+}
+
+// ── Main ─────────────────────────────────────────────────────────────
+
+function openCalendarPrivacySettings() {
+  try {
+    execFileSync('open', ['x-apple.systempreferences:com.apple.preference.security?Privacy_Calendars'], {
+      timeout: 5_000,
+    });
+    console.error('[calendar-sync] Opened System Settings > Privacy & Security > Calendars');
+  } catch {
+    console.error('[calendar-sync] Could not open System Settings automatically.');
+    console.error('[calendar-sync] Please open: System Settings > Privacy & Security > Calendars');
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function main() {
+  ensureBinary();
+
+  const MAX_RETRIES = 2;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const events = readEvents();
+      const stats = storeToBrain(events);
+      console.log(JSON.stringify(stats));
+      console.error(`[calendar-sync] Done: ${stats.inserted} new, ${stats.updated} updated, ${stats.skipped} unchanged`);
+      return;
+    } catch (err) {
+      const isAccessDenied = err.stderr && err.stderr.toString().includes('access_denied');
+      if (isAccessDenied && attempt < MAX_RETRIES) {
+        console.error(`[calendar-sync] Calendar access denied (attempt ${attempt + 1}/${MAX_RETRIES + 1}).`);
+        console.error('[calendar-sync] Opening System Settings — please grant Calendar access to your terminal app, then wait...');
+        openCalendarPrivacySettings();
+        await sleep(15_000); // wait 15s for user to toggle the checkbox
+        continue;
+      }
+      if (isAccessDenied) {
+        console.error('[calendar-sync] Calendar access still denied after retries.');
+        console.error('[calendar-sync] Grant access to your terminal in System Settings > Privacy & Security > Calendars');
+        process.exit(1);
+      }
+      console.error(`[calendar-sync] Error: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+main();

package/template/wall-e/skills/_bundled/memory-search/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: memory-search
+description: >
+  Search and summarize memories from WALL-E's brain. Performs multi-query
+  searches across Slack messages, chat history, and knowledge base.
+  Use for research, finding past conversations, and building context.
+version: 1.0.0
+author: juncao
+execution: agent
+trigger:
+  type: manual
+config:
+  query:
+    type: string
+    default: ""
+    description: "Search query or topic to research"
+  source:
+    type: string
+    enum: [all, slack, ctm, wall-e-chat]
+    default: all
+    description: "Filter to a specific memory source"
+  depth:
+    type: string
+    enum: [quick, deep]
+    default: quick
+    description: "quick = 1-2 searches, deep = exhaustive multi-query"
+tags: [search, memory, research, knowledge, context]
+permissions:
+  - brain:read
+---
+# Memory Search & Summarize
+
+## Your Goal
+
+Search WALL-E's brain for information on a given topic and produce a clear,
+organized summary of what was found. This skill is the foundation for
+answering questions about past conversations, decisions, and context.
+
+## Steps
+
+### 1. Understand the Query
+Parse the task description or config query to understand what information
+is being sought. Identify:
+- Key people involved
+- Time period of interest
+- Specific channels or topics
+- Whether this is a factual lookup or a pattern/trend analysis
+
+### 2. Execute Searches
+Use `search_memories` with MULTIPLE queries in the SAME turn:
+
+**For people-related queries:**
+- Search by person's name
+- Search by their common topics or projects
+- Search in Slack specifically (`source: "slack"`)
+
+**For topic-related queries:**
+- Search the topic directly
+- Search related/synonym terms
+- Search in both English and Chinese (the owner uses both)
+
+**For time-based queries:**
+- Search with date-range keywords
+- Search for events or milestones around that time
+
+### 3. Analyze & Cross-Reference
+Use the `think` tool to:
+- Identify patterns across search results
+- Note contradictions or evolving opinions
+- Distinguish between the owner's views and others' views
+- Consider what might be missing from the results
+
+### 4. Synthesize
+Produce a structured summary:
+
+**Key Findings**
+- Most important discoveries, with dates and people cited
+
+**Evidence**
+- Direct quotes from Slack messages (use > blockquotes)
+- Dates and channels for context
+
+**Gaps**
+- What information is missing or ambiguous
+- Suggested follow-up queries
+
+## Guidelines
+
+- Always cite sources: include timestamps and channel names
+- Translate Chinese content -- it often contains the most candid opinions
+- Distinguish between what the owner SAID vs what others SAID ABOUT/TO them
+- When evidence is thin, say so explicitly rather than speculating

package/template/wall-e/skills/_bundled/morning-briefing/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: morning-briefing
+description: >
+  Generate a morning briefing for the day ahead. Summarizes overnight Slack
+  activity, upcoming calendar events, pending tasks, and items needing
+  attention. Use for daily meeting prep and situational awareness.
+version: 2.0.0
+author: juncao
+execution: script
+entry: run.js
+trigger:
+  type: interval
+  schedule: "daily at 7am"
+tags: [briefing, morning, daily, summary, calendar, slack]
+permissions:
+  - brain:read
+  - calendar:read
+---
+# Morning Briefing
+
+## Your Goal
+
+Generate a concise, actionable morning briefing for the owner. This should take less than 2 minutes to read and highlight what needs attention TODAY.
+
+## Steps
+
+### 1. Check Calendar
+Use the `calendar_events` tool to get today's meetings and events. Note:
+- Meeting times and attendees
+- Back-to-back meetings that need prep
+- Any all-day events or deadlines
+
+### 2. Scan Overnight Slack Activity (USE BRAIN, NOT LIVE SLACK)
+**IMPORTANT**: All Slack data is already synced into WALL-E's brain. Use `search_memories`
+with `source: "slack"` — do NOT use `slack_search` or any live Slack API calls. The brain
+has 20,000+ Slack messages already indexed and searchable via FTS5.
+
+Run these searches IN PARALLEL (all in one turn):
+- `search_memories({query: "<owner name> mention", source: "slack", limit: 20})` — recent mentions
+- `search_memories({query: "<key project or topic>", source: "slack", limit: 15})` — active threads
+- `search_memories({source: "slack", limit: 30})` — latest messages across all channels
+
+Look for:
+- Direct mentions or questions directed at the owner
+- Active threads that need responses
+- Decisions made overnight that the owner should know about
+- Anything time-sensitive or blocking
+
+### 3. Check Pending Tasks
+Use `list_tasks` to see what's pending or overdue.
+
+### 4. Review Pending Questions
+Check if there are any pending questions from WALL-E that need the owner's input.
+
+## Output Format
+
+Structure the briefing as:
+
+### Today's Schedule
+- List meetings chronologically with times and key attendees
+
+### Overnight Activity
+- Summarize key Slack messages and threads needing attention
+- Highlight any urgent or time-sensitive items
+
+### Action Items
+A table of SPECIFIC, CONCRETE things the owner needs to do. Each item must have:
+- A clear next action (not just a topic — what exactly should they do?)
+- Who they need to talk to or respond to
+- A real deadline or reason for urgency
+
+| Action | Who | By When | Why |
+|--------|-----|---------|-----|
+| Reply to Alice's question about API migration in #eng-platform | Alice | Today | She's blocked waiting for your input |
+| Review PR #456 (database schema change) | Bob | Today | Merge deadline is EOD |
+| Prep talking points for 1:1 with VP at 2pm | Sarah | Before 2pm | Weekly sync, she raised perf concerns last week |
+
+**Rules for action items:**
+- NO vague items like "Follow up on project X" or "Monitor situation Y"
+- NO items that are just FYI — those go in Overnight Activity
+- Every item must answer: "What exactly should I DO, and WHY now?"
+- If there's nothing actionable, say "No action items — clean slate today"
+- Max 5 items. If more exist, prioritize ruthlessly.
+
+### Quick Stats
+- Pending tasks count
+- Any system alerts (e.g., Slack auth expiry, skill failures)
+
+## Structured Items Block (REQUIRED)
+
+After the markdown briefing, you MUST include a structured JSON block with all
+action items. This enables the UI to render interactive action buttons. Use this exact format:
+
+```
+<!-- BRIEFING_ITEMS
+[
+  {
+    "title": "Reply to Alice re: API migration — she's blocked",
+    "action": "Reply in #eng-platform thread or DM Alice",
+    "category": "comms|review|meeting-prep|decision|deliverable|other",
+    "who": "Alice Chen",
+    "urgency": "critical|today|this_week",
+    "why": "She's blocked on the schema decision and asked you directly yesterday",
+    "context": {
+      "search_queries": ["Alice API migration schema"],
+      "people": ["Alice Chen"],
+      "channels": ["eng-platform"]
+    }
+  }
+]
+-->
+```
+
+**Rules for BRIEFING_ITEMS:**
+- `title` must be a specific action, not a topic. "Reply to X" not "API migration"
+- `action` is what exactly to do (reply, review, prep, decide)
+- `why` explains urgency — why today and not tomorrow?
+- `who` is the specific person involved
+- Do NOT include async/FYI items — only things requiring action
+- Max 5 items
+
+Urgency levels:
+- `critical` = must act right now, someone is blocked
+- `today` = must handle today, has a deadline or meeting
+- `this_week` = due this week but not today
+
+## Tone
+
+Write like a sharp executive assistant briefing their boss. Be direct,
+prioritize ruthlessly, and flag anything that looks urgent or time-sensitive.
+Skip the pleasantries -- get straight to what matters.

package/template/wall-e/skills/_bundled/morning-briefing/run.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Morning Briefing — pure script, no Claude API calls.
+ *
+ * 1. Calendar events (today) via AppleScript
+ * 2. Recent Slack activity via brain FTS5 search
+ * 3. Pending tasks from brain
+ * 4. Pending questions from brain
+ *
+ * Outputs markdown to stdout. The task runner stores it as the task result.
+ */
+const path = require('path');
+const brain = require(path.resolve(__dirname, '..', '..', '..', 'brain'));
+const { getCalendarEvents } = require(path.resolve(__dirname, '..', '..', '..', 'tools', 'local-tools'));
+
+brain.initDb();
+const db = brain.getDb();
+
+async function main() {
+  const now = new Date();
+  const todayStr = now.toISOString().slice(0, 10);
+  const sections = [];
+
+  // ── 1. Today's Schedule ──
+  let calSection = "## Today's Schedule\n";
+  try {
+    const { events } = await getCalendarEvents({ days_ahead: 0 });
+    // Filter to today only
+    const todayEvents = events.filter(e => {
+      if (e.allDay) return true;
+      const eDate = new Date(e.start);
+      return !isNaN(eDate) && eDate.toISOString().slice(0, 10) === todayStr;
+    });
+    // De-duplicate by title + time
+    const seen = new Set();
+    const deduped = todayEvents.filter(e => {
+      const key = `${e.title}|${formatTime(e.start)}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    if (deduped.length === 0) {
+      calSection += '_No meetings today._\n';
+    } else {
+      for (const evt of deduped) {
+        const time = evt.allDay ? 'All day' : formatTime(evt.start);
+        // Show first names only for attendees, skip owner
+        const ownerEmail = (process.env.WALLE_OWNER_EMAIL || '').toLowerCase().trim();
+        const ownerPrefix = ownerEmail.includes('@') ? ownerEmail.split('@')[0] : '';
+        const filteredAttendees = evt.attendees
+          .filter(a => !ownerPrefix || !a.toLowerCase().includes(ownerPrefix))
+          .map(a => a.split('@')[0].split('.').filter(Boolean).map(s => s[0].toUpperCase() + s.slice(1)).join(' '));
+        const attendees = filteredAttendees.slice(0, 4);
+        const overflow = filteredAttendees.length > 4 ? ` +${filteredAttendees.length - 4}` : '';
+        const attendeeStr = attendees.length > 0 ? ` — ${attendees.join(', ')}${overflow}` : '';
+        calSection += `| **${time}** | ${evt.title}${attendeeStr} |\n`;
+      }
+    }
+  } catch (err) {
+    calSection += `_Calendar unavailable: ${err.message}_\n`;
+  }
+  sections.push(calSection);
+
+  // ── 2. Overnight Slack Activity (from brain) ──
+  const hoursBack = 18;
+  const cutoff = new Date(now.getTime() - hoursBack * 3600000).toISOString();
+
+  const recentInbound = db.prepare(`
+    SELECT content, source_channel, participants, timestamp
+    FROM memories
+    WHERE source = 'slack' AND direction = 'inbound'
+      AND timestamp > ?
+    ORDER BY timestamp DESC
+    LIMIT 30
+  `).all(cutoff);
+
+  const recentOutbound = db.prepare(`
+    SELECT content, source_channel, timestamp
+    FROM memories
+    WHERE source = 'slack' AND direction = 'outbound'
+      AND timestamp > ?
+    ORDER BY timestamp DESC
+    LIMIT 10
+  `).all(cutoff);
+
+  let slackSection = '## Overnight Slack\n';
+
+  if (recentInbound.length === 0 && recentOutbound.length === 0) {
+    slackSection += '_No Slack activity in the last 18 hours._\n';
+  } else {
+    // Group by channel, resolve channel names
+    const byChannel = {};
+    for (const msg of recentInbound) {
+      const ch = msg.source_channel || 'DM';
+      if (!byChannel[ch]) byChannel[ch] = [];
+      byChannel[ch].push(msg);
+    }
+
+    // Sort channels: most active first, top 6
+    const channels = Object.entries(byChannel)
+      .sort((a, b) => b[1].length - a[1].length)
+      .slice(0, 6);
+
+    for (const [channel, msgs] of channels) {
+      const chName = resolveChannelName(channel);
+      slackSection += `\n**${chName}** · ${msgs.length} message${msgs.length > 1 ? 's' : ''}\n`;
+      // Show up to 3 most recent, condensed
+      for (const msg of msgs.slice(0, 3)) {
+        const time = formatTime(msg.timestamp);
+        const who = extractFirstName(msg.participants);
+        const preview = condenseLine(msg.content, 120);
+        if (who) {
+          slackSection += `> **${who}** _(${time})_ — ${preview}\n`;
+        } else {
+          slackSection += `> _(${time})_ ${preview}\n`;
+        }
+      }
+      if (msgs.length > 3) {
+        slackSection += `> _+${msgs.length - 3} more_\n`;
+      }
+    }
+
+    if (recentOutbound.length > 0) {
+      slackSection += `\n_You sent ${recentOutbound.length} messages in the last ${hoursBack}h._\n`;
+    }
+  }
+  sections.push(slackSection);
+
+  // ── 3. Mentions & Urgent ──
+  let mentionSection = '';
+  try {
+    const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+    if (hasFts) {
+      const ownerFirst = (process.env.WALLE_OWNER_NAME || 'owner').split(' ')[0]
+        .replace(/['"*()]/g, ''); // sanitize FTS5 special chars
+      const matchExpr = `${ownerFirst} OR urgent OR blocked OR ASAP`;
+      const mentions = db.prepare(`
+        SELECT m.content, m.source_channel, m.participants, m.timestamp
+        FROM memories_fts f
+        JOIN memories m ON m.rowid = f.rowid
+        WHERE memories_fts MATCH ?
+          AND m.source = 'slack' AND m.timestamp > ?
+        ORDER BY m.timestamp DESC
+        LIMIT 5
+      `).all(matchExpr, cutoff);
+
+      if (mentions.length > 0) {
+        mentionSection = '\n## Mentions & Urgent\n';
+        for (const m of mentions) {
+          const time = formatTime(m.timestamp);
+          const ch = resolveChannelName(m.source_channel);
+          const who = extractFirstName(m.participants);
+          const preview = condenseLine(m.content, 140);
+          mentionSection += `> ${who ? `**${who}**` : ch} _(${time})_ — ${preview}\n`;
+        }
+      }
+    }
+  } catch {}
+  if (mentionSection) sections.push(mentionSection);
+
+  // ── 4. Pending Tasks ──
+  const tasks = brain.listTasks({ status: 'pending', limit: 10 });
+  const failedTasks = brain.listTasks({ status: 'failed', limit: 5 });
+  if (tasks.length > 0 || failedTasks.length > 0) {
+    let taskSection = '## Tasks\n';
+    if (tasks.length > 0) {
+      taskSection += '| Task | Priority | Due |\n|------|----------|-----|\n';
+      for (const t of tasks) {
+        const due = t.due_at ? t.due_at.slice(0, 10) : '—';
+        const pri = t.priority === 'urgent' ? '🔴 urgent' : t.priority === 'high' ? '🟡 high' : '—';
+        taskSection += `| ${t.title} | ${pri} | ${due} |\n`;
+      }
+    }
+    if (failedTasks.length > 0) {
+      taskSection += '\n**Failed:**\n';
+      for (const t of failedTasks) {
+        taskSection += `- ❌ ${t.title} — _${condenseLine(t.error || 'unknown', 60)}_\n`;
+      }
+    }
+    sections.push(taskSection);
+  }
+
+  // ── 5. Pending Questions ──
+  const questions = brain.listQuestions({ status: 'pending', limit: 5 });
+  if (questions.length > 0) {
+    let qSection = '## Questions for You\n';
+    for (const q of questions) {
+      qSection += `- **${q.question_type}**: ${q.question}\n`;
+    }
+    sections.push(qSection);
+  }
+
+  // ── 6. Quick Stats ──
+  const stats = brain.getBrainStats();
+  const totalSlack = db.prepare("SELECT count(*) as c FROM memories WHERE source = 'slack'").get().c;
+  let statsSection = '---\n';
+  statsSection += `📊 ${recentInbound.length} inbound · ${tasks.length} pending · ${questions.length} questions · ${stats.memory_count.toLocaleString()} memories · ${totalSlack.toLocaleString()} Slack\n`;
+  sections.push(statsSection);
+
+  // ── Output ──
+  const output = `# Morning Briefing — ${todayStr}\n\n${sections.join('\n')}`;
+  console.log(output);
+
+  brain.closeDb();
+}
+
+// ── Helpers ──
+
+function formatTime(dateStr) {
+  if (!dateStr) return '??:??';
+  try {
+    const d = new Date(dateStr);
+    if (isNaN(d.getTime())) {
+      const match = dateStr.match(/(\d{1,2}:\d{2}(?::\d{2})?\s*(?:AM|PM)?)/i);
+      return match ? match[1] : dateStr.slice(0, 16);
+    }
+    return d.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true });
+  } catch {
+    return dateStr.slice(0, 16);
+  }
+}
+
+// Resolve Slack channel IDs to readable names
+const CHANNEL_MAP = {};
+function resolveChannelName(channelId) {
+  if (!channelId) return '#unknown';
+  // If it looks like a readable name already (not all-caps+digits), use it
+  if (!channelId.match(/^[A-Z][A-Z0-9]{7,}$/)) return `#${channelId}`;
+  // Check cache
+  if (CHANNEL_MAP[channelId]) return CHANNEL_MAP[channelId];
+  // Fallback: shortened ID
+  CHANNEL_MAP[channelId] = `#${channelId.slice(0, 6)}…`;
+  return CHANNEL_MAP[channelId];
+}
+
+function extractFirstName(participants) {
+  if (!participants) return '';
+  // "Derek Holevinsky" → "Derek", "Yu Tan" → "Yu"
+  const name = participants.split(',')[0].trim().replace(/^\*+|\*+$/g, '');
+  return name.split(' ')[0] || name;
+}
+
+function condenseLine(text, maxLen) {
+  if (!text) return '';
+  let oneLine = text.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+  // Clean Slack formatting
+  oneLine = oneLine
+    .replace(/<@[A-Z0-9]+\|([^>]+)>/g, '@$1')     // <@U123|Name> → @Name
+    .replace(/<@[A-Z0-9]+>/g, '@someone')           // <@U123> → @someone
+    .replace(/<(https?:\/\/[^|>]+)\|([^>]+)>/g, '$2')  // <url|label> → label
+    .replace(/<(https?:\/\/[^>]+)>/g, '[link]')     // <url> → [link]
+    .replace(/:[a-z_-]+:/g, '')                        // :emoji: → remove
+    .replace(/<!(?:here|channel|everyone)>/g, '@here') // <!here> → @here
+    .replace(/\*([^*\n]+)\*/g, '$1')                   // *bold* → bold (avoid markdown clash)
+    .replace(/\s+/g, ' ').trim();
+  if (oneLine.length <= maxLen) return oneLine;
+  return oneLine.slice(0, maxLen - 1) + '…';
+}
+
+main().catch(err => {
+  console.error('[morning-briefing] Error:', err.message);
+  process.exit(1);
+});