create-metaclaw 3.3.0

package/installer/modules/boardroom/boardroom/db.ts.txt

@@ -0,0 +1,322 @@
+/**
+ * MetaClaw Boardroom — Database Layer
+ * SQLite WAL mode, local to coordinator machine only (never on network share)
+ */
+
+import Database from "better-sqlite3";
+import path from "path";
+import fs from "fs";
+
+let db: Database.Database | null = null;
+
+export function getBoardroomDb(dbPath?: string): Database.Database {
+  if (db) return db;
+  const p = dbPath || path.join(process.cwd(), "data", "boardroom.db");
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  db = new Database(p);
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 5000");
+  initSchema(db);
+  return db;
+}
+
+function initSchema(db: Database.Database) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS meetings (
+      id TEXT PRIMARY KEY,
+      topic TEXT NOT NULL,
+      created_by TEXT NOT NULL,
+      status TEXT DEFAULT 'active',
+      max_participants INTEGER DEFAULT 8,
+      scheduled_for TEXT,
+      time_limit_minutes INTEGER DEFAULT 30,
+      auto_end_at TEXT,
+      priority TEXT DEFAULT 'normal',
+      created_at TEXT DEFAULT (datetime('now')),
+      ended_at TEXT,
+      summary TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS scheduled_meetings (
+      id TEXT PRIMARY KEY,
+      topic TEXT NOT NULL,
+      created_by TEXT NOT NULL,
+      scheduled_for TEXT NOT NULL,
+      invited_agents TEXT DEFAULT '[]',
+      status TEXT DEFAULT 'scheduled',
+      meeting_id TEXT,
+      priority TEXT DEFAULT 'normal',
+      time_limit_minutes INTEGER DEFAULT 30,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS participants (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      meeting_id TEXT NOT NULL REFERENCES meetings(id),
+      agent_name TEXT NOT NULL,
+      expertise TEXT DEFAULT '[]',
+      status TEXT DEFAULT 'active',
+      joined_at TEXT DEFAULT (datetime('now')),
+      last_poll_at TEXT,
+      UNIQUE(meeting_id, agent_name)
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      meeting_id TEXT NOT NULL REFERENCES meetings(id),
+      agent_name TEXT NOT NULL,
+      content TEXT NOT NULL,
+      addresses TEXT,
+      msg_type TEXT DEFAULT 'statement',
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS turn_state (
+      meeting_id TEXT NOT NULL REFERENCES meetings(id),
+      agent_name TEXT NOT NULL,
+      wants_turn INTEGER DEFAULT 0,
+      last_spoke_at TEXT,
+      speak_count INTEGER DEFAULT 0,
+      PRIMARY KEY (meeting_id, agent_name)
+    );
+
+    CREATE TABLE IF NOT EXISTS hand_raises (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      meeting_id TEXT NOT NULL REFERENCES meetings(id),
+      agent_name TEXT NOT NULL,
+      raised_at TEXT DEFAULT (datetime('now')),
+      in_response_to INTEGER,
+      self_score REAL DEFAULT 0.5,
+      intent_hash TEXT DEFAULT '',
+      urgency TEXT DEFAULT 'normal',
+      status TEXT DEFAULT 'pending',
+      UNIQUE(meeting_id, agent_name, status)
+    );
+
+    CREATE TABLE IF NOT EXISTS meeting_artifacts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      meeting_id TEXT NOT NULL REFERENCES meetings(id),
+      artifact_type TEXT NOT NULL,
+      content TEXT NOT NULL,
+      assigned_to TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_meeting ON messages(meeting_id, id);
+    CREATE INDEX IF NOT EXISTS idx_participants_meeting ON participants(meeting_id);
+    CREATE INDEX IF NOT EXISTS idx_hand_raises_meeting ON hand_raises(meeting_id, status);
+    CREATE INDEX IF NOT EXISTS idx_scheduled_meetings ON scheduled_meetings(status, scheduled_for);
+  `);
+}
+
+// --- Meeting Operations ---
+
+export function createMeeting(db: Database.Database, id: string, topic: string, createdBy: string): void {
+  db.prepare("INSERT INTO meetings (id, topic, created_by) VALUES (?, ?, ?)").run(id, topic, createdBy);
+}
+
+export function getMeeting(db: Database.Database, id: string): any {
+  return db.prepare("SELECT * FROM meetings WHERE id = ?").get(id);
+}
+
+export function listActiveMeetings(db: Database.Database): any[] {
+  return db.prepare("SELECT id, topic, created_by, status, created_at FROM meetings WHERE status = 'active'").all();
+}
+
+export function endMeeting(db: Database.Database, id: string, summary?: string): void {
+  db.prepare("UPDATE meetings SET status = 'ended', ended_at = datetime('now'), summary = ? WHERE id = ?").run(summary || null, id);
+}
+
+// --- Participant Operations ---
+
+export function addParticipant(db: Database.Database, meetingId: string, agentName: string, expertise: string[]): void {
+  db.prepare(`
+    INSERT OR IGNORE INTO participants (meeting_id, agent_name, expertise) VALUES (?, ?, ?)
+  `).run(meetingId, agentName, JSON.stringify(expertise));
+  db.prepare(`
+    INSERT OR IGNORE INTO turn_state (meeting_id, agent_name) VALUES (?, ?)
+  `).run(meetingId, agentName);
+}
+
+export function getParticipants(db: Database.Database, meetingId: string): any[] {
+  return db.prepare("SELECT * FROM participants WHERE meeting_id = ? AND status = 'active'").all(meetingId);
+}
+
+export function updatePollTime(db: Database.Database, meetingId: string, agentName: string): void {
+  db.prepare("UPDATE participants SET last_poll_at = datetime('now') WHERE meeting_id = ? AND agent_name = ?").run(meetingId, agentName);
+}
+
+export function markIdleParticipants(db: Database.Database, meetingId: string, timeoutSeconds: number = 30): void {
+  db.prepare(`
+    UPDATE participants SET status = 'idle'
+    WHERE meeting_id = ? AND status = 'active'
+    AND last_poll_at IS NOT NULL
+    AND (julianday('now') - julianday(last_poll_at)) * 86400 > ?
+  `).run(meetingId, timeoutSeconds);
+}
+
+export function reactivateParticipant(db: Database.Database, meetingId: string, agentName: string): void {
+  db.prepare("UPDATE participants SET status = 'active', last_poll_at = datetime('now') WHERE meeting_id = ? AND agent_name = ?").run(meetingId, agentName);
+}
+
+// --- Message Operations ---
+
+export function addMessage(db: Database.Database, meetingId: string, agentName: string, content: string, addresses?: string[], msgType?: string): number {
+  const result = db.prepare(`
+    INSERT INTO messages (meeting_id, agent_name, content, addresses, msg_type)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(meetingId, agentName, content, addresses ? JSON.stringify(addresses) : null, msgType || "statement");
+
+  // Update turn state
+  db.prepare(`
+    UPDATE turn_state SET last_spoke_at = datetime('now'), speak_count = speak_count + 1, wants_turn = 0
+    WHERE meeting_id = ? AND agent_name = ?
+  `).run(meetingId, agentName);
+
+  return Number(result.lastInsertRowid);
+}
+
+export function getMessagesSince(db: Database.Database, meetingId: string, sinceId: number): any[] {
+  return db.prepare("SELECT * FROM messages WHERE meeting_id = ? AND id > ? ORDER BY id ASC").all(meetingId, sinceId);
+}
+
+export function getRecentMessages(db: Database.Database, meetingId: string, limit: number = 5): any[] {
+  return db.prepare("SELECT * FROM messages WHERE meeting_id = ? ORDER BY id DESC LIMIT ?").all(meetingId, limit).reverse();
+}
+
+export function getMessageCount(db: Database.Database, meetingId: string): number {
+  const row = db.prepare("SELECT COUNT(*) as count FROM messages WHERE meeting_id = ?").get(meetingId) as any;
+  return row?.count || 0;
+}
+
+// --- Turn State Operations ---
+
+export function getTurnStates(db: Database.Database, meetingId: string): any[] {
+  return db.prepare("SELECT * FROM turn_state WHERE meeting_id = ?").all(meetingId);
+}
+
+export function setWantsTurn(db: Database.Database, meetingId: string, agentName: string): void {
+  db.prepare("UPDATE turn_state SET wants_turn = 1 WHERE meeting_id = ? AND agent_name = ?").run(meetingId, agentName);
+}
+
+// --- Running Summary ---
+
+export function buildRunningSummary(db: Database.Database, meetingId: string): string | null {
+  const count = getMessageCount(db, meetingId);
+  if (count <= 5) return null;
+
+  // Get messages beyond the most recent 5
+  const older = db.prepare(`
+    SELECT agent_name, content, msg_type FROM messages
+    WHERE meeting_id = ? AND id NOT IN (
+      SELECT id FROM messages WHERE meeting_id = ? ORDER BY id DESC LIMIT 5
+    )
+    ORDER BY id ASC
+  `).all(meetingId, meetingId) as any[];
+
+  if (older.length === 0) return null;
+
+  const lines = older.map((m: any) => {
+    const prefix = m.msg_type === "question" ? "asked" : m.msg_type === "proposal" ? "proposed" : "said";
+    const snippet = m.content.length > 120 ? m.content.slice(0, 120) + "..." : m.content;
+    return `[${m.agent_name}] ${prefix}: ${snippet}`;
+  });
+
+  return lines.join("\n");
+}
+
+// --- Scheduling Operations ---
+
+export function createScheduledMeeting(db: Database.Database, id: string, topic: string, createdBy: string, scheduledFor: string, invited: string[], priority: string = "normal", timeLimit: number = 30): void {
+  db.prepare(`INSERT INTO scheduled_meetings (id, topic, created_by, scheduled_for, invited_agents, priority, time_limit_minutes) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+    .run(id, topic, createdBy, scheduledFor, JSON.stringify(invited), priority, timeLimit);
+}
+
+export function getUpcomingMeetings(db: Database.Database, agentName?: string): any[] {
+  const all = db.prepare("SELECT * FROM scheduled_meetings WHERE status = 'scheduled' ORDER BY scheduled_for ASC").all() as any[];
+  if (!agentName) return all;
+  return all.filter((m: any) => {
+    const invited = safeParseArr(m.invited_agents);
+    return m.created_by === agentName || invited.includes(agentName);
+  });
+}
+
+export function activateScheduledMeeting(db: Database.Database, scheduleId: string, meetingId: string): void {
+  db.prepare("UPDATE scheduled_meetings SET status = 'activated', meeting_id = ? WHERE id = ?").run(meetingId, scheduleId);
+}
+
+// --- Hand-Raise Operations ---
+
+export function raiseHand(db: Database.Database, meetingId: string, agentName: string, selfScore: number, intentHash: string, inResponseTo: number | null, urgency: string = "normal"): void {
+  // Withdraw any existing pending hand-raise
+  db.prepare("UPDATE hand_raises SET status = 'withdrawn' WHERE meeting_id = ? AND agent_name = ? AND status = 'pending'").run(meetingId, agentName);
+  // Insert new
+  db.prepare(`INSERT INTO hand_raises (meeting_id, agent_name, self_score, intent_hash, in_response_to, urgency) VALUES (?, ?, ?, ?, ?, ?)`)
+    .run(meetingId, agentName, selfScore, intentHash, inResponseTo, urgency);
+}
+
+export function lowerHand(db: Database.Database, meetingId: string, agentName: string): void {
+  db.prepare("UPDATE hand_raises SET status = 'withdrawn' WHERE meeting_id = ? AND agent_name = ? AND status = 'pending'").run(meetingId, agentName);
+}
+
+export function reEvaluateHand(db: Database.Database, meetingId: string, agentName: string, newScore: number, reason: string): void {
+  if (reason === "withdraw") {
+    lowerHand(db, meetingId, agentName);
+    return;
+  }
+  db.prepare("UPDATE hand_raises SET self_score = ? WHERE meeting_id = ? AND agent_name = ? AND status = 'pending'").run(newScore, meetingId, agentName);
+}
+
+export function getPendingHandRaises(db: Database.Database, meetingId: string): any[] {
+  return db.prepare("SELECT * FROM hand_raises WHERE meeting_id = ? AND status = 'pending' ORDER BY raised_at ASC").all(meetingId);
+}
+
+export function clearHandRaise(db: Database.Database, meetingId: string, agentName: string): void {
+  db.prepare("UPDATE hand_raises SET status = 'speaking' WHERE meeting_id = ? AND agent_name = ? AND status = 'pending'").run(meetingId, agentName);
+}
+
+export function expireStaleHandRaises(db: Database.Database, meetingId: string, maxAgeSec: number = 300): void {
+  db.prepare(`UPDATE hand_raises SET status = 'expired' WHERE meeting_id = ? AND status = 'pending' AND (julianday('now') - julianday(raised_at)) * 86400 > ?`).run(meetingId, maxAgeSec);
+}
+
+// --- Meeting Artifacts ---
+
+export function addArtifact(db: Database.Database, meetingId: string, type: string, content: string, assignedTo?: string): void {
+  db.prepare("INSERT INTO meeting_artifacts (meeting_id, artifact_type, content, assigned_to) VALUES (?, ?, ?, ?)").run(meetingId, type, content, assignedTo || null);
+}
+
+export function getArtifacts(db: Database.Database, meetingId: string): any[] {
+  return db.prepare("SELECT * FROM meeting_artifacts WHERE meeting_id = ? ORDER BY id").all(meetingId);
+}
+
+export function generateMeetingArtifacts(db: Database.Database, meetingId: string): any {
+  const meeting = getMeeting(db, meetingId);
+  const messages = db.prepare("SELECT * FROM messages WHERE meeting_id = ? ORDER BY id").all(meetingId) as any[];
+  const participants = getParticipants(db, meetingId);
+
+  const decisions = messages.filter((m: any) => m.msg_type === "decision");
+  const actionPattern = /(?:I will|I'll|action[: ]|TODO[: ]|will do|my task|assigned to me)/i;
+  const actionItems = messages.filter((m: any) => actionPattern.test(m.content));
+
+  for (const d of decisions) {
+    addArtifact(db, meetingId, "decision", d.content, d.agent_name);
+  }
+  for (const a of actionItems) {
+    addArtifact(db, meetingId, "action_item", a.content, a.agent_name);
+  }
+
+  return {
+    meeting_id: meetingId,
+    topic: meeting?.topic,
+    participant_count: participants.length,
+    message_count: messages.length,
+    decisions: decisions.length,
+    action_items: actionItems.length,
+  };
+}
+
+function safeParseArr(val: any): string[] {
+  if (Array.isArray(val)) return val;
+  if (typeof val === "string") { try { return JSON.parse(val); } catch { return []; } }
+  return [];
+}

package/installer/modules/boardroom/boardroom/meeting-agent.ts.txt

@@ -0,0 +1,129 @@
+/**
+ * MetaClaw Boardroom — Meeting Mode Agent Script
+ *
+ * When a cron agent detects a meeting, this script runs instead of the normal cycle.
+ * It joins the meeting, enters a polling loop, responds when signaled,
+ * and exits ONLY when the meeting ends.
+ *
+ * Usage: npx tsx boardroom/meeting-agent.ts <meeting_id> <agent_name> [coordinator_url]
+ */
+
+const meetingId = process.argv[2];
+const agentName = process.argv[3];
+const coordinator = process.argv[4] || "http://localhost:7890";
+
+if (!meetingId || !agentName) {
+  console.error("Usage: npx tsx boardroom/meeting-agent.ts <meeting_id> <agent_name> [coordinator_url]");
+  process.exit(1);
+}
+
+const POLL_INTERVAL = 2000; // 2 seconds
+let lastMessageId = 0;
+
+async function post(path: string, body: any): Promise<any> {
+  const res = await fetch(`${coordinator}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  return res.json();
+}
+
+async function get(path: string): Promise<any> {
+  const res = await fetch(`${coordinator}${path}`);
+  return res.json();
+}
+
+async function joinMeeting() {
+  console.log(`[${agentName}] Joining meeting ${meetingId}...`);
+  const result = await post(`/meetings/${meetingId}/join`, {
+    agent_name: agentName,
+    expertise: [], // Agent should fill this based on its config
+  });
+  console.log(`[${agentName}] Joined. Participants: ${result.context?.participants?.join(", ") || "unknown"}`);
+  console.log(`[${agentName}] Topic: ${result.context?.meeting_topic || "unknown"}`);
+  return result;
+}
+
+async function pollLoop() {
+  console.log(`[${agentName}] Entering meeting polling loop...`);
+
+  while (true) {
+    try {
+      const data = await get(`/meetings/${meetingId}/poll?agent=${encodeURIComponent(agentName)}&since=${lastMessageId}`);
+
+      // Meeting ended?
+      if (data.meeting_status === "ended") {
+        console.log(`[${agentName}] Meeting ended.`);
+        break;
+      }
+
+      // Process new messages
+      if (data.messages && data.messages.length > 0) {
+        for (const msg of data.messages) {
+          lastMessageId = Math.max(lastMessageId, msg.id);
+          if (msg.agent_name !== agentName) {
+            console.log(`[${msg.agent_name}]: ${msg.content.slice(0, 100)}${msg.content.length > 100 ? "..." : ""}`);
+          }
+        }
+      }
+
+      // Coverage check — should we re-evaluate?
+      if (data.coverage_check && data.coverage_check.action_required === "re-evaluate") {
+        console.log(`[${agentName}] Coverage detected — re-evaluating relevance...`);
+        // In a real implementation, the Claude session would evaluate this
+        // For now, we lower our score slightly
+        await post(`/meetings/${meetingId}/re-evaluate`, {
+          agent_name: agentName,
+          new_self_score: 0.4,
+          reason: "covered",
+        });
+      }
+
+      // Turn signal — should we speak?
+      if (data.turn_signal && data.turn_signal.should_speak) {
+        console.log(`[${agentName}] My turn (score: ${data.turn_signal.final_score || data.turn_signal.score}, reason: ${data.turn_signal.reason})`);
+        // In a real Claude session, the agent generates a thoughtful response here
+        // For this template, we signal readiness but the actual content comes from the Claude session
+        console.log(`[${agentName}] Generating response...`);
+        // The Claude session would call speak() here
+      }
+
+      // Queue position info
+      if (data.queue_position) {
+        console.log(`[${agentName}] Queue position: ${data.queue_position}/${data.queue_size}`);
+      }
+
+    } catch (err) {
+      console.error(`[${agentName}] Poll error (retrying):`, (err as Error).message);
+    }
+
+    await new Promise(r => setTimeout(r, POLL_INTERVAL));
+  }
+}
+
+async function main() {
+  try {
+    await joinMeeting();
+    await pollLoop();
+    console.log(`[${agentName}] Meeting mode complete. Returning to normal cycle.`);
+  } catch (err) {
+    console.error(`[${agentName}] Meeting mode error:`, err);
+  }
+
+  // Clean up
+  try {
+    const fs = await import("fs");
+    // Remove meeting lock
+    fs.unlinkSync("data/.meeting-lock");
+    // Remove MEETING_READY sentinel
+    const inbox = `__INBOX_ROOT__\\${agentName.toLowerCase()}`;
+    const files = fs.readdirSync(inbox).filter((f: string) => f.includes(`MEETING_READY_${meetingId}`));
+    for (const f of files) fs.unlinkSync(`${inbox}/${f}`);
+    // Remove MEETING_ENDED sentinel
+    const endFiles = fs.readdirSync(inbox).filter((f: string) => f.includes(`MEETING_ENDED_${meetingId}`));
+    for (const f of endFiles) fs.unlinkSync(`${inbox}/${f}`);
+  } catch {}
+}
+
+main();

package/installer/modules/boardroom/boardroom/meeting-scheduler.ts.txt

@@ -0,0 +1,194 @@
+/**
+ * MetaClaw Boardroom — Meeting Scheduler
+ *
+ * Scans inbox for boardroom summons with scheduled times.
+ * Sets timers to auto-join at the EXACT scheduled time.
+ * No early joins. No late joins. Precise.
+ *
+ * Usage:
+ *   Called at the start of every agent cycle:
+ *   npx tsx boardroom/meeting-scheduler.ts <agent_name>
+ *
+ *   Or run as a persistent watcher:
+ *   npx tsx boardroom/meeting-scheduler.ts <agent_name> --watch
+ */
+
+import fs from "fs";
+import path from "path";
+
+const agentName = process.argv[2];
+const watchMode = process.argv.includes("--watch");
+
+if (!agentName) {
+  console.error("Usage: npx tsx boardroom/meeting-scheduler.ts <agent_name> [--watch]");
+  process.exit(1);
+}
+
+const INBOX_PATH = path.join("__INBOX_ROOT__", agentName.toLowerCase());
+const PENDING_FILE = path.join(process.cwd(), "data", "pending-meetings.json");
+
+interface PendingMeeting {
+  meeting_id: string;
+  coordinator_url: string;
+  topic: string;
+  scheduled_time: string;  // ISO 8601 UTC
+  from: string;
+  timer_set: boolean;
+}
+
+function loadPending(): PendingMeeting[] {
+  try { return JSON.parse(fs.readFileSync(PENDING_FILE, "utf-8")); } catch { return []; }
+}
+
+function savePending(meetings: PendingMeeting[]) {
+  fs.mkdirSync(path.dirname(PENDING_FILE), { recursive: true });
+  fs.writeFileSync(PENDING_FILE, JSON.stringify(meetings, null, 2));
+}
+
+/**
+ * Scan inbox for boardroom summons with scheduled times
+ */
+function scanForSummons(): PendingMeeting[] {
+  if (!fs.existsSync(INBOX_PATH)) return [];
+  const files = fs.readdirSync(INBOX_PATH).filter(f => f.endsWith(".json"));
+  const found: PendingMeeting[] = [];
+
+  for (const file of files) {
+    try {
+      const msg = JSON.parse(fs.readFileSync(path.join(INBOX_PATH, file), "utf-8"));
+      if (msg.boardroom?.scheduled_time && msg.boardroom?.meeting_id) {
+        found.push({
+          meeting_id: msg.boardroom.meeting_id,
+          coordinator_url: msg.boardroom.coordinator_url || "http://localhost:7890",
+          topic: msg.boardroom.topic || msg.subject || "Meeting",
+          scheduled_time: msg.boardroom.scheduled_time,
+          from: msg.from || "unknown",
+          timer_set: false,
+        });
+      }
+    } catch {}
+  }
+  return found;
+}
+
+/**
+ * Join a meeting at the exact scheduled time
+ */
+async function joinAtExactTime(meeting: PendingMeeting) {
+  const scheduledMs = new Date(meeting.scheduled_time).getTime();
+  const now = Date.now();
+  const waitMs = scheduledMs - now;
+
+  if (waitMs < -300000) {
+    // More than 5 min past — meeting probably over
+    console.log(`[${agentName}] Meeting "${meeting.topic}" is ${Math.round(-waitMs/60000)} min past scheduled time. Skipping.`);
+    return;
+  }
+
+  if (waitMs > 0) {
+    console.log(`[${agentName}] Meeting "${meeting.topic}" in ${Math.round(waitMs/60000)} min. Waiting...`);
+    await new Promise(r => setTimeout(r, waitMs));
+  }
+
+  console.log(`[${agentName}] === JOINING MEETING: ${meeting.topic} ===`);
+
+  try {
+    // Join
+    const joinRes = await fetch(`${meeting.coordinator_url}/meetings/${meeting.meeting_id}/join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ agent_name: agentName, expertise: [] }),
+    });
+    const joinData = await joinRes.json();
+    console.log(`[${agentName}] Joined. Entering meeting loop...`);
+
+    // Meeting loop — stay until meeting ends
+    let lastMsgId = 0;
+    while (true) {
+      try {
+        const pollRes = await fetch(
+          `${meeting.coordinator_url}/meetings/${meeting.meeting_id}/poll?agent=${encodeURIComponent(agentName)}&since=${lastMsgId}`
+        );
+        const data = await pollRes.json();
+
+        if (data.meeting_status === "ended") {
+          console.log(`[${agentName}] Meeting ended.`);
+          break;
+        }
+
+        // Log new messages
+        if (data.messages?.length > 0) {
+          for (const msg of data.messages) {
+            lastMsgId = Math.max(lastMsgId, msg.id);
+            if (msg.agent_name !== agentName) {
+              console.log(`  [${msg.agent_name}]: ${msg.content.slice(0, 120)}...`);
+            }
+          }
+        }
+
+        // Turn signal
+        if (data.turn_signal?.should_speak) {
+          console.log(`[${agentName}] MY TURN (score: ${data.turn_signal.score || data.turn_signal.final_score}, reason: ${data.turn_signal.reason})`);
+          // In a real agent session, this is where the LLM generates a response
+          // The meeting-agent.ts or the Claude session handles the actual speaking
+        }
+      } catch (err) {
+        console.error(`[${agentName}] Poll error:`, (err as Error).message);
+      }
+
+      await new Promise(r => setTimeout(r, 2000));
+    }
+  } catch (err) {
+    console.error(`[${agentName}] Join failed:`, (err as Error).message);
+  }
+
+  // Clean up: remove from pending
+  const pending = loadPending().filter(m => m.meeting_id !== meeting.meeting_id);
+  savePending(pending);
+}
+
+/**
+ * Main: scan, schedule, join
+ */
+async function main() {
+  // Load existing pending meetings
+  let pending = loadPending();
+
+  // Scan inbox for new summons
+  const newSummons = scanForSummons();
+  for (const s of newSummons) {
+    if (!pending.find(p => p.meeting_id === s.meeting_id)) {
+      pending.push(s);
+      console.log(`[${agentName}] New meeting scheduled: "${s.topic}" at ${s.scheduled_time} from ${s.from}`);
+    }
+  }
+  savePending(pending);
+
+  // Check for meetings that should be joined NOW (within next 5 min)
+  const now = Date.now();
+  const imminent = pending.filter(m => {
+    const scheduledMs = new Date(m.scheduled_time).getTime();
+    const diff = scheduledMs - now;
+    return diff < 300000 && diff > -300000; // Within 5 min window
+  });
+
+  if (imminent.length > 0) {
+    console.log(`[${agentName}] ${imminent.length} meeting(s) imminent. Joining...`);
+    // Join the first one (if multiple, join highest priority)
+    await joinAtExactTime(imminent[0]);
+  } else if (pending.length > 0) {
+    const next = pending.sort((a, b) => new Date(a.scheduled_time).getTime() - new Date(b.scheduled_time).getTime())[0];
+    const minUntil = Math.round((new Date(next.scheduled_time).getTime() - now) / 60000);
+    console.log(`[${agentName}] Next meeting: "${next.topic}" in ${minUntil} min.`);
+
+    if (watchMode) {
+      // In watch mode, wait for the meeting
+      console.log(`[${agentName}] Watch mode — waiting for meeting time...`);
+      await joinAtExactTime(next);
+    }
+  } else {
+    console.log(`[${agentName}] No pending meetings.`);
+  }
+}
+
+main().catch(console.error);