create-metaclaw 3.3.0

package/installer/modules/boardroom/boardroom/turn-v2.ts.txt

@@ -0,0 +1,172 @@
+/**
+ * MetaClaw Boardroom — Turn-Taking v2
+ *
+ * Dynamic priority queue with 5 signals:
+ *   1. Self-assessment (25%) — agent's own relevance judgment
+ *   2. Direct address (25%) — were they called on by name
+ *   3. Freshness (20%) — are they responding to recent conversation
+ *   4. Equity (15%) — balance participation
+ *   5. Urgency (15%) — critical > high > normal
+ *   × Staleness decay — old hand-raises lose weight
+ *
+ * After every message, ALL waiting agents re-evaluate.
+ * The queue reorders dynamically based on current conversation state.
+ */
+
+import type Database from "better-sqlite3";
+import { getRecentMessages, getMessageCount, getTurnStates, getParticipants, getPendingHandRaises, expireStaleHandRaises } from "./db.js";
+
+const V2_WEIGHTS = {
+  self_score: 0.25,
+  address: 0.25,
+  freshness: 0.20,
+  equity: 0.15,
+  urgency: 0.15,
+};
+
+const THRESHOLD = 20;
+
+export interface QueueEntry {
+  agent_name: string;
+  final_score: number;
+  components: {
+    self_score: number;
+    address_score: number;
+    freshness_score: number;
+    equity_score: number;
+    urgency_bonus: number;
+    staleness_decay: number;
+  };
+  reason: string;
+  should_speak: boolean;
+  intent_hash: string;
+  in_response_to: number | null;
+}
+
+export function computePriorityQueue(meetingId: string, db: Database.Database): QueueEntry[] {
+  // Expire old hand-raises
+  expireStaleHandRaises(db, meetingId, 300);
+
+  const handRaises = getPendingHandRaises(db, meetingId);
+  if (handRaises.length === 0) return [];
+
+  const recentMessages = getRecentMessages(db, meetingId, 5);
+  const currentMsgCount = getMessageCount(db, meetingId);
+  const turnStates = getTurnStates(db, meetingId);
+  const maxSpeakCount = Math.max(1, ...turnStates.map((t: any) => t.speak_count || 0));
+  const now = Date.now();
+
+  const queue: QueueEntry[] = [];
+
+  for (const hr of handRaises as any[]) {
+    // 1. SELF_SCORE — agent's own assessment
+    const selfScore = (hr.self_score || 0.5) * 100;
+
+    // 2. ADDRESS_SCORE — were they called on
+    const addressScore = scoreDirectAddress(hr.agent_name, recentMessages);
+
+    // 3. FRESHNESS_SCORE — responding to recent conversation?
+    let freshnessScore = 100;
+    if (hr.in_response_to) {
+      const pos = db.prepare("SELECT COUNT(*) as pos FROM messages WHERE meeting_id = ? AND id <= ?")
+        .get(meetingId, hr.in_response_to) as any;
+      const gap = currentMsgCount - (pos?.pos || 0);
+      freshnessScore = Math.max(0, 100 - gap * 30);
+    }
+
+    // 4. EQUITY_SCORE — balance participation
+    const myState = turnStates.find((t: any) => t.agent_name === hr.agent_name);
+    const mySpeakCount = myState?.speak_count || 0;
+    const equityScore = Math.max(10, 100 - (mySpeakCount / maxSpeakCount) * 90);
+
+    // 5. URGENCY_BONUS
+    const urgencyMap: Record<string, number> = { critical: 100, high: 70, normal: 30 };
+    const urgencyBonus = urgencyMap[hr.urgency] || 30;
+
+    // STALENESS_DECAY — old hand-raises lose weight
+    const raisedAt = new Date(hr.raised_at + "Z").getTime();
+    const secondsSinceRaise = (now - raisedAt) / 1000;
+    const stalenessDecay = Math.max(0.3, 1.0 - secondsSinceRaise / 300);
+
+    // COMPOSITE
+    const rawScore =
+      selfScore * V2_WEIGHTS.self_score +
+      addressScore * V2_WEIGHTS.address +
+      freshnessScore * V2_WEIGHTS.freshness +
+      equityScore * V2_WEIGHTS.equity +
+      urgencyBonus * V2_WEIGHTS.urgency;
+
+    const finalScore = Math.round(rawScore * stalenessDecay);
+
+    // Build reason
+    const reasons: string[] = [];
+    if (selfScore >= 70) reasons.push("high self-assessment");
+    if (addressScore >= 70) reasons.push("directly addressed");
+    if (freshnessScore >= 70) reasons.push("responding to recent");
+    if (equityScore >= 80) reasons.push("hasn't spoken much");
+    if (hr.urgency === "critical") reasons.push("CRITICAL");
+    else if (hr.urgency === "high") reasons.push("high urgency");
+    if (stalenessDecay < 0.7) reasons.push("hand-raise aging");
+
+    queue.push({
+      agent_name: hr.agent_name,
+      final_score: finalScore,
+      components: { self_score: selfScore, address_score: addressScore, freshness_score: freshnessScore, equity_score: equityScore, urgency_bonus: urgencyBonus, staleness_decay: stalenessDecay },
+      reason: reasons.join(", ") || "in queue",
+      should_speak: finalScore >= THRESHOLD,
+      intent_hash: hr.intent_hash || "",
+      in_response_to: hr.in_response_to,
+    });
+  }
+
+  // Sort: critical urgency always first, then by score, then by equity (less talkative wins ties)
+  queue.sort((a, b) => {
+    // Critical urgency trumps everything
+    if (a.components.urgency_bonus === 100 && b.components.urgency_bonus !== 100) return -1;
+    if (b.components.urgency_bonus === 100 && a.components.urgency_bonus !== 100) return 1;
+    // Then by score
+    if (b.final_score !== a.final_score) return b.final_score - a.final_score;
+    // Tie-break: less talkative goes first
+    return a.components.equity_score - b.components.equity_score;
+  });
+
+  return queue;
+}
+
+export function getNextSpeakerV2(meetingId: string, db: Database.Database): QueueEntry | null {
+  const queue = computePriorityQueue(meetingId, db);
+  return queue.length > 0 && queue[0].should_speak ? queue[0] : null;
+}
+
+export function scoreForAgentV2(meetingId: string, agentName: string, db: Database.Database): QueueEntry | null {
+  const queue = computePriorityQueue(meetingId, db);
+  return queue.find(q => q.agent_name === agentName) || null;
+}
+
+// Check if another agent's message overlaps with a pending hand-raise
+export function checkCoverage(intentHash: string, messageContent: string): number {
+  if (!intentHash || !messageContent) return 0;
+  const intentWords = new Set(intentHash.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+  const msgWords = new Set(messageContent.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+  let overlap = 0;
+  for (const w of intentWords) {
+    if (msgWords.has(w)) overlap++;
+  }
+  return intentWords.size > 0 ? overlap / intentWords.size : 0;
+}
+
+// --- Helper ---
+function scoreDirectAddress(agentName: string, recentMessages: any[]): number {
+  if (recentMessages.length === 0) return 0;
+  const nameLower = agentName.toLowerCase();
+  let best = 0;
+
+  for (const msg of recentMessages) {
+    let addresses: string[] = [];
+    try { addresses = typeof msg.addresses === "string" ? JSON.parse(msg.addresses) : (msg.addresses || []); } catch {}
+    if (addresses.some((a: string) => a.toLowerCase() === nameLower)) return 100;
+    if (msg.content.toLowerCase().includes(nameLower)) best = Math.max(best, 70);
+    if (msg.msg_type === "question" && msg.agent_name !== agentName) best = Math.max(best, 30);
+  }
+  return best;
+}

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

@@ -0,0 +1,208 @@
+/**
+ * MetaClaw Boardroom — Intelligent Turn-Taking Algorithm
+ * 4-signal scoring: direct address (40%), expertise (30%), recency (20%), pending (10%)
+ */
+
+import type Database from "better-sqlite3";
+import type { TurnScore } from "./types.js";
+import { getRecentMessages, getTurnStates, getParticipants } from "./db.js";
+
+const WEIGHTS = {
+  direct_address: 0.40,
+  expertise: 0.30,
+  recency: 0.20,
+  pending_flag: 0.10,
+};
+
+const THRESHOLD = 30;
+
+// Common words to skip when matching expertise
+const STOP_WORDS = new Set([
+  "the", "and", "for", "are", "but", "not", "you", "all", "can", "had",
+  "her", "was", "one", "our", "out", "has", "have", "this", "that", "with",
+  "they", "been", "from", "will", "what", "when", "make", "like", "just",
+  "over", "such", "take", "than", "them", "very", "some", "could", "other",
+  "into", "more", "also", "back", "after", "should", "would", "about",
+  "think", "know", "going", "want", "need", "meeting", "agent", "yeah",
+]);
+
+export function scoreTurns(
+  meetingId: string,
+  db: Database.Database,
+  excludeAgent?: string
+): TurnScore[] {
+  const participants = getParticipants(db, meetingId);
+  const activeParticipants = participants.filter((p: any) => p.status === "active");
+  const recentMessages = getRecentMessages(db, meetingId, 3);
+  const turnStates = getTurnStates(db, meetingId);
+  const turnMap = new Map(turnStates.map((t: any) => [t.agent_name, t]));
+
+  const scores: TurnScore[] = [];
+
+  for (const p of activeParticipants) {
+    const name = p.agent_name;
+    if (name === excludeAgent) continue;
+
+    const ts = turnMap.get(name) || { wants_turn: 0, last_spoke_at: null, speak_count: 0 };
+    const expertise: string[] = safeParseJson(p.expertise, []);
+
+    // Signal 1: Direct Address
+    const addressScore = scoreDirectAddress(name, recentMessages);
+
+    // Signal 2: Expertise Relevance
+    const expertiseScore = scoreExpertise(expertise, recentMessages);
+
+    // Signal 3: Recency
+    const recencyScore = scoreRecency(ts, turnStates);
+
+    // Signal 4: Pending Flag
+    const pendingScore = ts.wants_turn ? 100 : 0;
+
+    const composite = Math.round(
+      addressScore * WEIGHTS.direct_address +
+      expertiseScore * WEIGHTS.expertise +
+      recencyScore * WEIGHTS.recency +
+      pendingScore * WEIGHTS.pending_flag
+    );
+
+    const reasons: string[] = [];
+    if (addressScore > 50) reasons.push("addressed directly");
+    if (expertiseScore > 50) reasons.push("expertise match");
+    if (recencyScore > 70) reasons.push("hasn't spoken recently");
+    if (ts.wants_turn) reasons.push("requested turn");
+
+    scores.push({
+      agent_name: name,
+      score: composite,
+      reason: reasons.length > 0 ? reasons.join(", ") : "waiting",
+      should_speak: composite >= THRESHOLD,
+    });
+  }
+
+  // Sort by score descending, then by speak_count ascending (less talkative wins ties)
+  scores.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    const tsA = turnMap.get(a.agent_name);
+    const tsB = turnMap.get(b.agent_name);
+    return (tsA?.speak_count || 0) - (tsB?.speak_count || 0);
+  });
+
+  return scores;
+}
+
+export function getNextSpeaker(
+  meetingId: string,
+  db: Database.Database,
+  lastSpeaker?: string
+): TurnScore | null {
+  const scores = scoreTurns(meetingId, db, lastSpeaker);
+  return scores.length > 0 && scores[0].should_speak ? scores[0] : null;
+}
+
+export function scoreForAgent(
+  meetingId: string,
+  agentName: string,
+  db: Database.Database
+): TurnScore {
+  const all = scoreTurns(meetingId, db);
+  return all.find(s => s.agent_name === agentName) || {
+    agent_name: agentName,
+    score: 0,
+    reason: "not in meeting",
+    should_speak: false,
+  };
+}
+
+// --- Signal Scoring Functions ---
+
+function scoreDirectAddress(agentName: string, recentMessages: any[]): number {
+  if (recentMessages.length === 0) return 0;
+
+  const nameLower = agentName.toLowerCase();
+  let best = 0;
+
+  for (const msg of recentMessages) {
+    // Check explicit addresses field
+    const addresses: string[] = safeParseJson(msg.addresses, []);
+    if (addresses.some((a: string) => a.toLowerCase() === nameLower)) {
+      return 100; // Explicitly addressed
+    }
+
+    // Check content for name mentions
+    const contentLower = msg.content.toLowerCase();
+    if (contentLower.includes(nameLower)) {
+      best = Math.max(best, 70);
+    }
+
+    // Check if it's a question (increases likelihood someone should respond)
+    if (msg.msg_type === "question" && msg.agent_name !== agentName) {
+      best = Math.max(best, 30);
+    }
+  }
+
+  return best;
+}
+
+function scoreExpertise(expertise: string[], recentMessages: any[]): number {
+  if (expertise.length === 0 || recentMessages.length === 0) return 0;
+
+  const expertiseLower = new Set(expertise.map(e => e.toLowerCase()));
+
+  // Extract meaningful words from recent messages
+  const messageWords = new Set<string>();
+  for (const msg of recentMessages) {
+    const words = msg.content.toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, " ")
+      .split(/\s+/)
+      .filter((w: string) => w.length > 3 && !STOP_WORDS.has(w));
+    words.forEach((w: string) => messageWords.add(w));
+  }
+
+  // Count matches
+  let matches = 0;
+  for (const tag of expertiseLower) {
+    // Check exact match and partial match (tag "pricing" matches word "pricing")
+    for (const word of messageWords) {
+      if (word.includes(tag) || tag.includes(word)) {
+        matches++;
+        break;
+      }
+    }
+  }
+
+  return Math.min(100, Math.round((matches / expertise.length) * 100));
+}
+
+function scoreRecency(turnState: any, allTurnStates: any[]): number {
+  // Never spoken = maximum recency score
+  if (!turnState.last_spoke_at) return 100;
+
+  const lastSpoke = new Date(turnState.last_spoke_at + "Z").getTime();
+  const now = Date.now();
+
+  // Find the most recent speaker's time
+  let mostRecent = 0;
+  let oldest = Infinity;
+  for (const ts of allTurnStates) {
+    if (ts.last_spoke_at) {
+      const t = new Date(ts.last_spoke_at + "Z").getTime();
+      mostRecent = Math.max(mostRecent, t);
+      oldest = Math.min(oldest, t);
+    }
+  }
+
+  if (mostRecent === oldest) return 50; // Everyone spoke at the same time
+
+  // Scale: most recent speaker = 0, oldest speaker = 100
+  const range = mostRecent - oldest;
+  if (range === 0) return 50;
+  return Math.round(((mostRecent - lastSpoke) / range) * 100);
+}
+
+function safeParseJson(val: any, fallback: any): any {
+  if (Array.isArray(val)) return val;
+  if (typeof val === "string") {
+    try { return JSON.parse(val); } catch { return fallback; }
+  }
+  return fallback;
+}

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

@@ -0,0 +1,100 @@
+/**
+ * MetaClaw Boardroom — Shared Types
+ * Multi-agent meeting system with intelligent turn-taking
+ */
+
+export interface Meeting {
+  id: string;
+  topic: string;
+  created_by: string;
+  status: "active" | "paused" | "ended";
+  max_participants: number;
+  created_at: string;
+  ended_at: string | null;
+  summary: string | null;
+}
+
+export interface Participant {
+  id: number;
+  meeting_id: string;
+  agent_name: string;
+  expertise: string[];
+  status: "active" | "left" | "idle";
+  joined_at: string;
+  last_poll_at: string | null;
+}
+
+export interface Message {
+  id: number;
+  meeting_id: string;
+  agent_name: string;
+  content: string;
+  addresses: string[] | null;
+  msg_type: "statement" | "question" | "proposal" | "decision" | "summary";
+  created_at: string;
+}
+
+export interface TurnState {
+  meeting_id: string;
+  agent_name: string;
+  wants_turn: boolean;
+  last_spoke_at: string | null;
+  speak_count: number;
+}
+
+export interface TurnScore {
+  agent_name: string;
+  score: number;
+  reason: string;
+  should_speak: boolean;
+}
+
+export interface ContextPackage {
+  meeting_topic: string;
+  meeting_id: string;
+  participants: string[];
+  recent_messages: Message[];
+  running_summary: string | null;
+  your_turn: TurnScore;
+  total_messages: number;
+}
+
+export interface PollResult {
+  messages: Message[];
+  turn_signal: TurnScore;
+  context: ContextPackage | null;
+}
+
+export interface CreateMeetingRequest {
+  topic: string;
+  created_by: string;
+  expertise?: string[];
+}
+
+export interface JoinMeetingRequest {
+  agent_name: string;
+  expertise?: string[];
+}
+
+export interface SpeakRequest {
+  agent_name: string;
+  content: string;
+  addresses?: string[];
+  msg_type?: Message["msg_type"];
+}
+
+export interface MeetingSummons {
+  id: string;
+  from: string;
+  to: string;
+  timestamp: string;
+  subject: string;
+  body: string;
+  type: "request";
+  priority: "high";
+  boardroom: {
+    meeting_id: string;
+    coordinator_url: string;
+    topic: string;
+  };
+}

package/installer/modules/boardroom/metaclaw-module.json

@@ -0,0 +1,35 @@
+{
+  "name": "boardroom",
+  "displayName": "Boardroom — Agent Meetings",
+  "version": "1.0.0",
+  "description": "Multi-agent meeting system: scheduling, intelligent turn-taking, persistent attendance, post-meeting artifacts",
+  "category": "collaboration",
+  "alwaysInstall": true,
+  "engines": { "metaclaw": ">=3.3.0" },
+  "requires": { "modules": ["core"] },
+  "contributes": {
+    "boardroom": {
+      "types.ts.txt": "boardroom/types.ts",
+      "db.ts.txt": "boardroom/db.ts",
+      "turn.ts.txt": "boardroom/turn.ts",
+      "turn-v2.ts.txt": "boardroom/turn-v2.ts",
+      "server.ts.txt": "boardroom/server.ts",
+      "client.ts.txt": "boardroom/client.ts",
+      "summons.ts.txt": "boardroom/summons.ts",
+      "meeting-agent.ts.txt": "boardroom/meeting-agent.ts",
+      "meeting-scheduler.ts.txt": "boardroom/meeting-scheduler.ts",
+      "start-boardroom.bat.txt": "boardroom/start-boardroom.bat"
+    },
+    "scripts": {
+      "meeting-check.bat.txt": "scripts/meeting-check.bat"
+    },
+    "npmScripts": {
+      "boardroom": "tsx boardroom/server.ts",
+      "boardroom-start": "tsx boardroom/server.ts --port 7890",
+      "meeting-check": "tsx boardroom/meeting-scheduler.ts"
+    },
+    "claudeMd": ["boardroom"],
+    "directories": ["boardroom"]
+  },
+  "placeholders": ["__PROJECT_DIR__", "__COORDINATOR_URL__"]
+}

package/installer/modules/boardroom/scripts/meeting-check.bat.txt

@@ -0,0 +1,38 @@
+@echo off
+REM MetaClaw Boardroom — Meeting Check
+REM Called at the start of every agent cycle.
+REM Checks if this agent has an active meeting to attend.
+REM Returns ERRORLEVEL 0 = meeting found (enter meeting mode)
+REM Returns ERRORLEVEL 1 = no meeting (proceed with normal cycle)
+
+setlocal enabledelayedexpansion
+set "AGENT_NAME=%~1"
+set "COORDINATOR=__COORDINATOR_URL__"
+set "INBOX=__INBOX_ROOT__\%AGENT_NAME%"
+set "MEETING_ID="
+
+REM Check 1: MEETING_READY sentinel file in inbox
+for %%f in ("%INBOX%\MEETING_READY_*.json") do (
+    if exist "%%f" (
+        echo [MEETING] Found meeting-ready sentinel: %%~nf
+        REM Extract meeting_id from the JSON file
+        for /f "usebackq tokens=*" %%j in (`node -e "const d=JSON.parse(require('fs').readFileSync('%%f','utf-8'));console.log(d.meeting_id)"`) do (
+            set "MEETING_ID=%%j"
+        )
+        if defined MEETING_ID (
+            echo !MEETING_ID!> "data\.meeting-id"
+            exit /b 0
+        )
+    )
+)
+
+REM Check 2: Active meeting where this agent is a participant
+for /f "usebackq delims=" %%r in (`node -e "fetch('%COORDINATOR%/meetings').then(r=>r.json()).then(d=>{const m=d.meetings.find(m=>m.status==='active');if(m)console.log(m.id);else console.log('NONE')}).catch(()=>console.log('NONE'))"`) do (
+    if not "%%r"=="NONE" (
+        echo [MEETING] Active meeting found: %%r
+        echo %%r> "data\.meeting-id"
+        exit /b 0
+    )
+)
+
+exit /b 1

package/installer/modules/core/metaclaw-module.json

@@ -0,0 +1,51 @@
+{
+  "name": "core",
+  "displayName": "Core — Database, Safety & Self-Improvement",
+  "version": "3.3.0",
+  "description": "Foundation: SQLite database, safety guardrails, observability, self-improvement, health checks, state management, hooks system",
+  "category": "foundation",
+  "alwaysInstall": true,
+  "engines": { "metaclaw": ">=3.3.0" },
+  "requires": { "modules": [], "env": [], "bins": ["node"] },
+  "contributes": {
+    "src": {
+      "db.ts.txt": "src/db.ts",
+      "safety.ts.txt": "src/safety.ts",
+      "observability.ts.txt": "src/observability.ts",
+      "self-improve.ts.txt": "src/self-improve.ts",
+      "self-update.ts.txt": "src/self-update.ts",
+      "health-check.ts.txt": "src/health-check.ts",
+      "tasks.ts.txt": "src/tasks.ts",
+      "scan-capabilities.ts.txt": "src/scan-capabilities.ts",
+      "sync-context.ts.txt": "src/sync-context.ts"
+    },
+    "data": {
+      "state.json.txt": "data/state.json",
+      "system-context.json.txt": "data/system-context.json"
+    },
+    "memory": {
+      "CAPABILITIES.md.txt": "memory/CAPABILITIES.md",
+      "stuck-patterns.md.txt": "memory/stuck-patterns.md",
+      "logic-log.jsonl.txt": "memory/logic-log.jsonl",
+      "reflections.jsonl.txt": "memory/reflections.jsonl",
+      "curiosity.md.txt": "memory/curiosity.md"
+    },
+    "npmScripts": {
+      "status": "tsx src/agent.ts --status",
+      "self-update": "tsx src/self-update.ts",
+      "health-check": "tsx src/health-check.ts",
+      "scan": "tsx src/scan-capabilities.ts",
+      "sync-context": "tsx src/sync-context.ts"
+    },
+    "claudeMd": ["identity", "first-launch", "meta-cognition", "state-management", "tasks", "commands"],
+    "directories": ["src", "src/tools", "data", "data/logs", "scripts", "memory", "memory/capabilities"],
+    "dependencies": {
+      "@anthropic-ai/claude-agent-sdk": "latest",
+      "@types/better-sqlite3": "latest",
+      "better-sqlite3": "latest",
+      "tsx": "latest",
+      "typescript": "latest"
+    }
+  },
+  "placeholders": ["__AGENT_NAME__", "__SESSION_NAME__", "__CLAW_TYPE__", "__TIMESTAMP__", "__SAFETY_CONFIG__", "__SYSTEM_PROMPT__"]
+}