quoroom 0.1.21 → 0.1.23

package/out/mcp/api-server.js

@@ -9914,7 +9914,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "quoroom",
-      version: "0.1.21",
+      version: "0.1.23",
       description: "Autonomous AI agent collective engine \u2014 Queen, Workers, Quorum",
       main: "./out/mcp/server.js",
       bin: {
@@ -9939,7 +9939,7 @@ var require_package = __commonJS({
         "build:mcp": "node scripts/build-mcp.js",
         "build:ui": "vite build --config src/ui/vite.config.ts",
         "kill:ports": "node scripts/kill-ports.js",
-        "kill:dev-ports": "npm run kill:ports -- 4700 3710 5173",
+        "kill:dev-ports": "npm run kill:ports -- 4700 3715 5173",
         "dev:links": "node scripts/dev-links.js",
         dev: `sh -c 'npm run kill:dev-ports && trap "kill 0" INT TERM EXIT; npm run dev:links & npm run dev:room & npm run dev:cloud & wait'`,
         "dev:room": "sh -c 'export QUOROOM_DATA_DIR=$HOME/.quoroom-dev QUOROOM_SKIP_MCP_REGISTER=1; npm run build:mcp && npm run build:ui && node scripts/dev-server.js --port 4700'",
@@ -9947,7 +9947,7 @@ var require_package = __commonJS({
         "dev:room:shared": "npm run build:mcp && npm run build:ui && node scripts/dev-server.js",
         "doctor:split": "node scripts/doctor-split.js",
         "dev:isolated": `sh -c 'npm run kill:dev-ports && trap "kill 0" INT TERM EXIT; npm run dev:links & npm run dev:room:isolated & npm run dev:cloud & VITE_API_PORT=4700 npm run dev:ui & wait'`,
-        "dev:cloud": `sh -c 'npm run kill:ports -- 3710 && cd ../cloud && PORT=3710 CLOUD_PUBLIC_URL=http://127.0.0.1:3710 CLOUD_ALLOWED_ORIGINS='"'"'http://127.0.0.1:3710,http://localhost:3710,http://localhost:5173,http://127.0.0.1:5173,https://quoroom.ai,https://www.quoroom.ai,https://app.quoroom.ai'"'"' npm start'`,
+        "dev:cloud": `sh -c 'npm run kill:ports -- 3715 && cd ../cloud && PORT=3715 CLOUD_PUBLIC_URL=http://127.0.0.1:3715 CLOUD_ALLOWED_ORIGINS='"'"'http://127.0.0.1:3715,http://localhost:3715,http://localhost:5173,http://127.0.0.1:5173,https://quoroom.ai,https://www.quoroom.ai,https://app.quoroom.ai'"'"' npm start'`,
         "dev:ui": "vite --config src/ui/vite.config.ts",
         "seed:style-demo": "sh -c 'export QUOROOM_DATA_DIR=$HOME/.quoroom-dev; node scripts/seed-style-demo.js'",
         typecheck: "tsc --noEmit",
@@ -12069,6 +12069,7 @@ function mapRoomRow(row) {
     queenNickname: row.queen_nickname ?? null,
     chatSessionId: row.chat_session_id ?? null,
     referredByCode: row.referred_by_code ?? null,
+    allowedTools: row.allowed_tools ?? null,
     webhookToken: row.webhook_token ?? null,
     createdAt: row.created_at,
     updatedAt: row.updated_at
@@ -12161,6 +12162,7 @@ function updateRoom(db2, id, updates) {
     config: "config",
     referredByCode: "referred_by_code",
     queenNickname: "queen_nickname",
+    allowedTools: "allowed_tools",
     webhookToken: "webhook_token"
   };
   const fields = [];
@@ -12799,6 +12801,10 @@ function listRoomMessages(db2, roomId, status2) {
 function markRoomMessageRead(db2, id) {
   db2.prepare("UPDATE room_messages SET status = 'read' WHERE id = ?").run(id);
 }
+function markAllRoomMessagesRead(db2, roomId) {
+  const result = db2.prepare("UPDATE room_messages SET status = 'read' WHERE room_id = ? AND status = 'unread'").run(roomId);
+  return result.changes;
+}
 function replyToRoomMessage(db2, id) {
   db2.prepare("UPDATE room_messages SET status = 'replied' WHERE id = ?").run(id);
 }
@@ -12856,6 +12862,22 @@ function listRoomCycles(db2, roomId, limit = 20) {
   ).all(roomId, safeLimit);
   return rows.map(mapWorkerCycleRow);
 }
+function countProductiveToolCalls(db2, workerId, lastNCycles = 2) {
+  const row = db2.prepare(`
+    SELECT COUNT(*) as cnt FROM cycle_logs
+    WHERE cycle_id IN (
+      SELECT id FROM worker_cycles
+      WHERE worker_id = ? AND status = 'completed'
+      ORDER BY started_at DESC LIMIT ?
+    )
+    AND entry_type = 'tool_call'
+    AND (content LIKE '%web_search%' OR content LIKE '%web_fetch%' OR content LIKE '%remember%'
+      OR content LIKE '%send_message%' OR content LIKE '%inbox_send%'
+      OR content LIKE '%update_progress%' OR content LIKE '%complete_goal%'
+      OR content LIKE '%set_goal%' OR content LIKE '%delegate_task%' OR content LIKE '%propose%' OR content LIKE '%vote%')
+  `).get(workerId, lastNCycles);
+  return row.cnt;
+}
 function cleanupStaleCycles(db2) {
   const result = db2.prepare(
     "UPDATE worker_cycles SET status = 'failed', error_message = 'Server restarted', finished_at = datetime('now','localtime') WHERE status = 'running'"
@@ -22503,11 +22525,13 @@ async function sendToken(db2, roomId, to, amount, encryptionKey, network = "base
 var DEFAULT_QUEEN_SYSTEM_PROMPT = `You are the Queen agent of this Room \u2014 the strategic coordinator.
 Your role is to pursue the room's objectives by:
 - Decomposing goals into actionable sub-goals
-- Creating and delegating to worker agents
+- **Delegating tasks to workers** using quoroom_delegate_task \u2014 this is your primary way to get work done
 - Proposing decisions to the quorum
 - Self-improving your strategies and skills based on results
 - Managing resources efficiently
 
+**Delegation is key.** You have workers \u2014 use them. Break work into concrete tasks and assign each to a worker with quoroom_delegate_task. Workers see their assigned tasks each cycle and will prioritize them. Coordinate via quoroom_send_message. Don't do everything yourself \u2014 delegate, then focus on strategy, coordination, and quality control.
+
 You have access to all room MCP tools. Use them to manage goals, workers, skills, and decisions.
 
 Quorum: Use quoroom_propose to create proposals (types: strategy, resource, personnel, rule_change, low_impact). Low-impact proposals may be auto-approved. Use quoroom_vote to cast your vote (yes/no/abstain) with reasoning. Use quoroom_list_decisions and quoroom_decision_detail to review pending and past decisions.
@@ -22518,7 +22542,7 @@ Revenue: Your room has a USDC wallet. Beyond pursuing the room's core objectives
 
 Resource Management: Workers using API models (openai:*, anthropic:*) run on stations (cloud compute) \u2014 they cannot execute locally. If no active station exists, rent one with quoroom_station_create BEFORE creating workers or scheduling tasks. Minimum tier: small ($25/mo, 2GB RAM). Check the Stations section in your context each cycle for available compute. Maximize use of your room's stations \u2014 they are your compute power for running workers. If workers are failing with "no active station" errors, rent a station immediately.
 
-Network Growth: A larger network of rooms makes everyone stronger. Rooms created through your invite links become part of your network \u2014 you can exchange knowledge, discover money-making opportunities, and propose paid collaborations with them via inter-room messages. After meaningful milestones (goal completed, revenue earned, successful collaboration), consider generating an invite link with quoroom_invite_create and sharing it with the keeper via quoroom_inbox_send_keeper. Frame it around the value: more rooms in the network means more potential deals, shared insights, and collective intelligence. Don't be pushy \u2014 one mention per milestone is enough. Use quoroom_invite_network to see your network's growth.`;
+Network Growth: A larger network of rooms makes everyone stronger. Rooms created through your invite links become part of your network \u2014 you can exchange knowledge, discover money-making opportunities, and propose paid collaborations with them via inter-room messages. After meaningful milestones (goal completed, revenue earned, successful collaboration), consider generating an invite link with quoroom_invite_create and sharing it with the keeper via quoroom_send_message. Frame it around the value: more rooms in the network means more potential deals, shared insights, and collective intelligence. Don't be pushy \u2014 one mention per milestone is enough. Use quoroom_invite_network to see your network's growth.`;
 function createRoom2(db2, input) {
   const config = { ...DEFAULT_ROOM_CONFIG, ...input.config };
   const room = createRoom(db2, input.name, input.goal, config, input.referredByCode);
@@ -23981,33 +24005,131 @@ async function closeBrowser() {
   }
 }
 async function webFetch(url) {
-  const jinaUrl = `https://r.jina.ai/${url}`;
-  const response = await fetch(jinaUrl, {
-    headers: {
-      "Accept": "text/plain",
-      "X-No-Cache": "true"
-    },
-    signal: AbortSignal.timeout(3e4)
+  try {
+    const jinaUrl = `https://r.jina.ai/${url}`;
+    const response = await fetch(jinaUrl, {
+      headers: { "Accept": "text/plain", "X-No-Cache": "true" },
+      signal: AbortSignal.timeout(2e4)
+    });
+    if (response.ok) {
+      const text = await response.text();
+      if (text.length > 200 && !text.includes("Warning: Target URL returned error")) {
+        return text.slice(0, MAX_CONTENT_CHARS);
+      }
+    }
+  } catch {
+  }
+  return fetchWithBrowser(url);
+}
+async function fetchWithBrowser(url) {
+  const browser = await getBrowser();
+  const context = await browser.newContext({
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
   });
-  if (!response.ok) {
-    throw new Error(`Jina fetch failed: ${response.status} ${response.statusText}`);
+  const page = await context.newPage();
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    const text = await page.innerText("body").catch(() => "");
+    if (!text) throw new Error(`Could not read content from ${url}`);
+    return text.slice(0, MAX_CONTENT_CHARS);
+  } finally {
+    await context.close();
   }
-  const text = await response.text();
-  return text.slice(0, MAX_CONTENT_CHARS);
 }
 async function webSearch(query) {
-  const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-  const response = await fetch(searchUrl, {
-    headers: {
-      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-    },
-    signal: AbortSignal.timeout(15e3)
+  const browserResults = await searchWithBrowser(query);
+  if (browserResults.length > 0) return browserResults;
+  const ddgResults = await searchDdg(query);
+  if (ddgResults.length > 0) return ddgResults;
+  try {
+    const response = await fetch(`https://s.jina.ai/${encodeURIComponent(query)}`, {
+      headers: { "Accept": "application/json", "X-No-Cache": "true" },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.data && Array.isArray(data.data)) {
+        return data.data.slice(0, 5).map((r) => ({
+          title: r.title ?? "",
+          url: r.url ?? "",
+          snippet: (r.description ?? r.content ?? "").slice(0, 300)
+        })).filter((r) => r.url);
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+async function searchWithBrowser(query) {
+  let browser;
+  try {
+    browser = await getBrowser();
+  } catch {
+    return [];
+  }
+  const context = await browser.newContext({
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    locale: "en-US"
   });
-  if (!response.ok) {
-    throw new Error(`DuckDuckGo search failed: ${response.status}`);
+  const page = await context.newPage();
+  try {
+    await page.goto(`https://search.yahoo.com/search?p=${encodeURIComponent(query)}`, {
+      waitUntil: "domcontentloaded",
+      timeout: 15e3
+    });
+    await page.waitForTimeout(1e3);
+    const results = await page.evaluate(() => {
+      const items = [];
+      const blocks = document.querySelectorAll("#web .algo, .dd.algo, .algo");
+      for (const block of blocks) {
+        const link = block.querySelector("a");
+        const h3 = block.querySelector("h3");
+        const snippetEl = block.querySelector(".compText p, .compText, p");
+        if (!link) continue;
+        const url = link.getAttribute("href") || "";
+        if (!url.startsWith("http")) continue;
+        items.push({
+          title: h3 ? (h3.textContent || "").trim() : (link.textContent || "").trim(),
+          url,
+          snippet: snippetEl ? (snippetEl.textContent || "").trim().slice(0, 300) : ""
+        });
+        if (items.length >= 5) break;
+      }
+      return items;
+    });
+    return results.filter((r) => r.url);
+  } catch {
+    return [];
+  } finally {
+    await context.close();
   }
-  const html = await response.text();
-  return parseDdgResults(html).slice(0, 5);
+}
+async function searchDdg(query) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (attempt > 0) await new Promise((r) => setTimeout(r, 1e3 * attempt));
+    try {
+      const response = await fetch("https://html.duckduckgo.com/html/", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+          "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+          "Accept-Language": "en-US,en;q=0.9",
+          "Referer": "https://html.duckduckgo.com/"
+        },
+        body: `q=${encodeURIComponent(query)}&b=`,
+        signal: AbortSignal.timeout(15e3),
+        redirect: "follow"
+      });
+      if (response.status === 202) continue;
+      if (!response.ok) continue;
+      const html = await response.text();
+      const results = parseDdgResults(html).slice(0, 5);
+      if (results.length > 0) return results;
+    } catch {
+    }
+  }
+  return [];
 }
 function parseDdgResults(html) {
   const results = [];
@@ -24159,6 +24281,22 @@ var QUEEN_TOOL_DEFINITIONS = [
       }
     }
   },
+  {
+    type: "function",
+    function: {
+      name: "quoroom_delegate_task",
+      description: 'Delegate a task to a specific worker. Creates a goal assigned to that worker. The worker will see it in their "Your Assigned Tasks" context. Use this to divide work among your team.',
+      parameters: {
+        type: "object",
+        properties: {
+          workerName: { type: "string", description: "The worker name to assign to (from Room Workers list)" },
+          task: { type: "string", description: "Description of the task to delegate" },
+          parentGoalId: { type: "number", description: "Optional parent goal ID to attach as sub-goal" }
+        },
+        required: ["workerName", "task"]
+      }
+    }
+  },
   {
     type: "function",
     function: {
@@ -24319,18 +24457,19 @@ var QUEEN_TOOL_DEFINITIONS = [
       }
     }
   },
-  // ── Keeper messaging ───────────────────────────────────────────────────
+  // ── Messaging ──────────────────────────────────────────────────────────
   {
     type: "function",
     function: {
-      name: "quoroom_ask_keeper",
-      description: "Send a question or request to the keeper (human operator). Use for decisions that require human input.",
+      name: "quoroom_send_message",
+      description: "Send a message to the keeper or another worker. The keeper sees all messages. Use to coordinate with teammates, report progress, ask for help, or escalate to the keeper.",
       parameters: {
         type: "object",
         properties: {
-          question: { type: "string", description: "The question or request for the keeper" }
+          to: { type: "string", description: 'Recipient: "keeper" or a worker name from Room Workers list' },
+          message: { type: "string", description: "The message content" }
         },
-        required: ["question"]
+        required: ["to", "message"]
       }
     }
   },
@@ -24402,6 +24541,47 @@ var QUEEN_TOOL_DEFINITIONS = [
         required: ["url", "actions"]
       }
     }
+  },
+  // ── Wallet ──────────────────────────────────────────────────────────────
+  {
+    type: "function",
+    function: {
+      name: "quoroom_wallet_balance",
+      description: "Get the room's wallet balance (USDC). Returns address and transaction summary.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "quoroom_wallet_send",
+      description: "Send USDC from the room's wallet to an address.",
+      parameters: {
+        type: "object",
+        properties: {
+          to: { type: "string", description: "Recipient address (0x...)" },
+          amount: { type: "string", description: 'Amount (e.g., "10.50")' }
+        },
+        required: ["to", "amount"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "quoroom_wallet_history",
+      description: "Get recent wallet transaction history.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "string", description: "Max transactions to return (default: 10)" }
+        }
+      }
+    }
   }
 ];
 async function executeQueenTool(db2, roomId, workerId, toolName, args) {
@@ -24422,10 +24602,12 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
         if (goalCheck.roomId !== roomId) return { content: `Error: goal #${goalId} belongs to another room. Your room's goals are shown in the Active Goals section \u2014 use those goal IDs.`, isError: true };
         const observation = String(args.observation ?? args.progress ?? args.message ?? args.text ?? "");
         const metricValue = args.metricValue != null ? Number(args.metricValue) : args.metric_value != null ? Number(args.metric_value) : void 0;
+        const subGoals = getSubGoals(db2, goalId);
         updateGoalProgress(db2, goalId, observation, metricValue, workerId);
         const goal = getGoal(db2, goalId);
         const pct = Math.round((goal?.progress ?? 0) * 100);
-        return { content: `Progress logged on goal #${goalId}. Now at ${pct}%.` };
+        const note = subGoals.length > 0 && metricValue != null ? ` (metricValue ignored \u2014 goal has ${subGoals.length} sub-goals, progress is calculated from them. Update sub-goals directly.)` : "";
+        return { content: `Progress logged on goal #${goalId}. Now at ${pct}%.${note}` };
       }
       case "quoroom_create_subgoal": {
         const goalId = Number(args.goalId);
@@ -24437,6 +24619,32 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
         const subGoals = decomposeGoal(db2, goalId, descriptions);
         return { content: `Created ${subGoals.length} sub-goal(s) under goal #${goalId}.` };
       }
+      case "quoroom_delegate_task": {
+        const workerName = String(args.workerName ?? args.worker ?? args.to ?? "").trim();
+        const task = String(args.task ?? args.description ?? args.goal ?? "").trim();
+        if (!workerName) return { content: 'Error: "workerName" is required (a worker name from Room Workers list).', isError: true };
+        if (!task) return { content: 'Error: "task" is required (description of the task to delegate).', isError: true };
+        const roomWorkers = listRoomWorkers(db2, roomId);
+        const target = roomWorkers.find((w) => w.name.toLowerCase() === workerName.toLowerCase());
+        if (!target) {
+          const available = roomWorkers.filter((w) => w.id !== workerId).map((w) => w.name).join(", ");
+          return { content: `Worker "${workerName}" not found. Available: ${available || "none"}`, isError: true };
+        }
+        const parentGoalId = args.parentGoalId != null ? Number(args.parentGoalId) : void 0;
+        if (parentGoalId != null) {
+          const parentCheck = getGoal(db2, parentGoalId);
+          if (!parentCheck) return { content: `Error: parent goal #${parentGoalId} not found.`, isError: true };
+          if (parentCheck.roomId !== roomId) return { content: `Error: parent goal #${parentGoalId} belongs to another room.`, isError: true };
+        }
+        const goal = createGoal(db2, roomId, task, parentGoalId, target.id);
+        if (parentGoalId) {
+          const parentGoal = getGoal(db2, parentGoalId);
+          if (parentGoal && parentGoal.status === "active") {
+            updateGoal(db2, parentGoalId, { status: "in_progress" });
+          }
+        }
+        return { content: `Task delegated to ${target.name}: "${task}" (goal #${goal.id})` };
+      }
       case "quoroom_complete_goal": {
         const goalId = Number(args.goalId);
         const goalCheck = getGoal(db2, goalId);
@@ -24458,6 +24666,13 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
       case "quoroom_propose": {
         const proposalText = String(args.proposal ?? args.text ?? args.description ?? args.content ?? args.idea ?? "").trim();
         if (!proposalText) return { content: 'Error: proposal text is required. Provide a "proposal" string.', isError: true };
+        const recentDecisions = listDecisions(db2, roomId);
+        const isDuplicate = recentDecisions.slice(0, 10).some(
+          (d) => (d.status === "voting" || d.status === "approved") && d.proposal.toLowerCase() === proposalText.toLowerCase()
+        );
+        if (isDuplicate) {
+          return { content: `A similar proposal already exists: "${proposalText}". No need to propose again.`, isError: true };
+        }
         const decisionType = String(args.decisionType ?? args.type ?? args.impact ?? args.category ?? "low_impact");
         const decision = propose(db2, {
           roomId,
@@ -24498,6 +24713,10 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
         const systemPrompt = String(args.systemPrompt ?? args.system_prompt ?? args.instructions ?? args.prompt ?? "").trim();
         if (!name) return { content: 'Error: name is required for quoroom_create_worker. Provide a "name" string.', isError: true };
         if (!systemPrompt) return { content: `Error: systemPrompt is required for quoroom_create_worker. Provide a "systemPrompt" string describing this worker's role and instructions.`, isError: true };
+        const existingWorkers = listRoomWorkers(db2, roomId);
+        if (existingWorkers.some((w) => w.name.toLowerCase() === name.toLowerCase())) {
+          return { content: `Worker "${name}" already exists in this room. Use quoroom_update_worker to modify it, or choose a different name.`, isError: true };
+        }
         const role = args.role && args.role !== args.name ? String(args.role) : void 0;
         const description = args.description ? String(args.description) : void 0;
         const preset = role ? WORKER_ROLE_PRESETS[role] : void 0;
@@ -24530,6 +24749,10 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
         const taskWorkerId = args.workerId ? Number(args.workerId) : void 0;
         const maxTurns = args.maxTurns ? Number(args.maxTurns) : void 0;
         const triggerType = cronExpression ? "cron" : scheduledAt ? "once" : "manual";
+        const existingTasks = listTasks(db2, roomId, "active");
+        if (existingTasks.some((t) => t.name.toLowerCase() === name.toLowerCase())) {
+          return { content: `Task "${name}" already exists. Choose a different name or manage the existing task.`, isError: true };
+        }
         if (taskWorkerId) {
           const taskWorker = getWorker(db2, taskWorkerId);
           if (!taskWorker || taskWorker.roomId !== roomId) {
@@ -24555,6 +24778,11 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
         const name = String(args.name ?? "");
         const content = String(args.content ?? "");
         const type = String(args.type ?? "fact");
+        const existing = listEntities(db2, roomId).find((e) => e.name.toLowerCase() === name.toLowerCase());
+        if (existing) {
+          addObservation(db2, existing.id, content, "queen");
+          return { content: `Updated memory "${name}" (added new observation to existing entry).` };
+        }
         const entity = createEntity(db2, name, type, void 0, roomId);
         addObservation(db2, entity.id, content, "queen");
         return { content: `Remembered "${name}".` };
@@ -24569,13 +24797,27 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
         }).join("\n");
         return { content: summary };
       }
-      // ── Keeper messaging ─────────────────────────────────────────────
-      case "quoroom_ask_keeper": {
-        const question = String(args.question ?? "");
-        const escalation = createEscalation(db2, roomId, workerId, question);
-        const deliveryStatus = await deliverQueenMessage(db2, roomId, question);
-        const deliveryNote = deliveryStatus ? ` ${deliveryStatus}` : "";
-        return { content: `Question sent to keeper (escalation #${escalation.id}).${deliveryNote}` };
+      // ── Messaging ────────────────────────────────────────────────────
+      case "quoroom_send_message": {
+        const to = String(args.to ?? "").trim();
+        const message = String(args.message ?? args.question ?? "").trim();
+        if (!to) return { content: 'Error: "to" is required ("keeper" or a worker name).', isError: true };
+        if (!message) return { content: 'Error: "message" is required.', isError: true };
+        if (to.toLowerCase() === "keeper") {
+          const escalation2 = createEscalation(db2, roomId, workerId, message);
+          const deliveryStatus = await deliverQueenMessage(db2, roomId, message);
+          const deliveryNote = deliveryStatus ? ` ${deliveryStatus}` : "";
+          return { content: `Message sent to keeper (#${escalation2.id}).${deliveryNote}` };
+        }
+        const roomWorkers = listRoomWorkers(db2, roomId);
+        const target = roomWorkers.find((w) => w.name.toLowerCase() === to.toLowerCase());
+        if (!target) {
+          const available = roomWorkers.filter((w) => w.id !== workerId).map((w) => w.name).join(", ");
+          return { content: `Worker "${to}" not found. Available: ${available || "none"}`, isError: true };
+        }
+        if (target.id === workerId) return { content: "Cannot send a message to yourself.", isError: true };
+        const escalation = createEscalation(db2, roomId, workerId, message, target.id);
+        return { content: `Message sent to ${target.name} (#${escalation.id}).` };
       }
       // ── Room config ──────────────────────────────────────────────────
       case "quoroom_configure_room": {
@@ -24609,6 +24851,26 @@ async function executeQueenTool(db2, roomId, workerId, toolName, args) {
         if (!url) return { content: "Error: url is required", isError: true };
         return { content: await browserAction(url, actions) };
       }
+      // ── Wallet ────────────────────────────────────────────────────
+      case "quoroom_wallet_balance": {
+        const wallet = getWalletByRoom(db2, roomId);
+        if (!wallet) return { content: "No wallet found for this room.", isError: true };
+        const summary = getWalletTransactionSummary(db2, wallet.id);
+        const net = (parseFloat(summary.received) - parseFloat(summary.sent)).toFixed(2);
+        return { content: `Wallet ${wallet.address}: ${net} USDC (received: ${summary.received}, sent: ${summary.sent})` };
+      }
+      case "quoroom_wallet_send": {
+        return { content: "Wallet send requires on-chain transaction \u2014 use the MCP tool quoroom_wallet_send with encryptionKey, or ask the keeper to send funds.", isError: true };
+      }
+      case "quoroom_wallet_history": {
+        const wallet = getWalletByRoom(db2, roomId);
+        if (!wallet) return { content: "No wallet found for this room.", isError: true };
+        const limit = Math.min(Number(args.limit) || 10, 50);
+        const txs = listWalletTransactions(db2, wallet.id, limit);
+        if (txs.length === 0) return { content: "No transactions yet." };
+        const lines = txs.map((tx) => `[${tx.type}] ${tx.amount} USDC \u2014 ${tx.description ?? ""} (${tx.status})`).join("\n");
+        return { content: lines };
+      }
       default:
         return { content: `Unknown tool: ${toolName}`, isError: true };
     }
@@ -24873,7 +25135,8 @@ async function runCycle(db2, roomId, worker, maxTurns, options) {
       id: g.id,
       goal: g.description,
       progress: g.progress,
-      status: g.status
+      status: g.status,
+      assignedWorkerId: g.assignedWorkerId
     }));
     const roomWorkers = listRoomWorkers(db2, roomId);
     const roomTasks = listTasks(db2, roomId, "active").slice(0, 10);
@@ -24979,10 +25242,21 @@ ${skillContent}` : ""
 ${status2.room.goal}`);
     }
     if (goalUpdates.length > 0) {
+      const workerMap = new Map(roomWorkers.map((w) => [w.id, w.name]));
       contextParts.push(`## Active Goals
-${goalUpdates.map(
-        (g) => `- [#${g.id}] [${Math.round(g.progress * 100)}%] ${g.goal} (${g.status})`
-      ).join("\n")}`);
+${goalUpdates.map((g) => {
+        const assignee = g.assignedWorkerId ? ` \u2192 ${workerMap.get(g.assignedWorkerId) ?? `Worker #${g.assignedWorkerId}`}` : "";
+        return `- [#${g.id}] [${Math.round(g.progress * 100)}%] ${g.goal} (${g.status})${assignee}`;
+      }).join("\n")}`);
+      const myTasks = status2.activeGoals.filter((g) => g.assignedWorkerId === worker.id);
+      if (myTasks.length > 0) {
+        contextParts.push(`## Your Assigned Tasks
+${myTasks.map(
+          (g) => `- [#${g.id}] [${Math.round(g.progress * 100)}%] ${g.description}`
+        ).join("\n")}
+
+These tasks were delegated to you. Prioritize completing them and report progress.`);
+      }
     }
     const memoryEntities = listEntities(db2, roomId).slice(0, 20);
     if (memoryEntities.length > 0) {
@@ -25011,19 +25285,21 @@ ${recentResolved.map((d) => {
         return `- ${icon} ${d.status}: "${d.proposal.slice(0, 120)}"`;
       }).join("\n")}`);
     }
-    const pendingToKeeper = pendingEscalations.filter((e) => e.fromAgentId === worker.id && !e.toAgentId);
-    const pendingFromOthers = pendingEscalations.filter((e) => e.fromAgentId !== worker.id);
-    if (pendingToKeeper.length > 0) {
-      contextParts.push(`## Pending Questions to Keeper (awaiting keeper reply)
-${pendingToKeeper.map(
+    const myKeeperMessages = pendingEscalations.filter((e) => e.fromAgentId === worker.id && !e.toAgentId);
+    const incomingWorkerMessages = pendingEscalations.filter((e) => e.toAgentId === worker.id && e.fromAgentId !== worker.id);
+    if (myKeeperMessages.length > 0) {
+      contextParts.push(`## Pending Messages to Keeper (awaiting reply)
+${myKeeperMessages.map(
         (e) => `- #${e.id}: ${e.question}`
       ).join("\n")}`);
     }
-    if (pendingFromOthers.length > 0) {
-      contextParts.push(`## Escalations Awaiting Your Response
-${pendingFromOthers.map(
-        (e) => `- #${e.id}: ${e.question}`
-      ).join("\n")}`);
+    if (incomingWorkerMessages.length > 0) {
+      const senderNames = new Map(roomWorkers.map((w) => [w.id, w.name]));
+      contextParts.push(`## Messages from Other Workers
+${incomingWorkerMessages.map((e) => {
+        const sender = senderNames.get(e.fromAgentId ?? 0) ?? `Worker #${e.fromAgentId}`;
+        return `- #${e.id} from ${sender}: ${e.question}`;
+      }).join("\n")}`);
     }
     if (recentKeeperAnswers.length > 0) {
       contextParts.push(`## Keeper Answers (recent)
@@ -25051,6 +25327,14 @@ ${roomTasks.map(
         (t) => `- #${t.id} "${t.name}" [${t.triggerType}] \u2014 ${t.status}`
       ).join("\n")}`);
     }
+    const wallet = getWalletByRoom(db2, roomId);
+    if (wallet) {
+      const summary = getWalletTransactionSummary(db2, wallet.id);
+      const net = (parseFloat(summary.received) - parseFloat(summary.sent)).toFixed(2);
+      contextParts.push(`## Wallet
+Address: ${wallet.address}
+Balance: ${net} USDC (received: ${summary.received}, spent: ${summary.sent})`);
+    }
     if (unreadMessages.length > 0) {
       contextParts.push(`## Unread Messages
 ${unreadMessages.map(
@@ -25088,26 +25372,62 @@ ${top3.map(
     }
     contextParts.push(`## Execution Settings
 ${settingsParts.join("\n")}`);
+    const STUCK_THRESHOLD_CYCLES = 2;
+    const productiveCallCount = countProductiveToolCalls(db2, worker.id, STUCK_THRESHOLD_CYCLES);
+    const recentCompletedCycles = listRoomCycles(db2, roomId, 5).filter((c) => c.workerId === worker.id && c.status === "completed");
+    const isStuck = recentCompletedCycles.length >= STUCK_THRESHOLD_CYCLES && productiveCallCount === 0;
+    if (isStuck) {
+      contextParts.push(`## \u26A0 STUCK DETECTED
+Your last ${STUCK_THRESHOLD_CYCLES} cycles produced no external results (no web searches, no memories stored, no goal progress, no keeper messages). You MUST change strategy NOW:
+- Try a different web search query
+- Store what you know in memory even if incomplete
+- Update goal progress with what you've learned
+- Message the keeper if you're blocked
+Do NOT repeat the same approach. Pivot immediately.`);
+      logBuffer.addSynthetic("system", `Stuck detector: 0 productive tool calls in last ${STUCK_THRESHOLD_CYCLES} cycles \u2014 injecting pivot directive`);
+    }
     const selfRegulateHint = rateLimitEvents.length > 0 ? "\n- **Self-regulate**: You are hitting rate limits. Use quoroom_configure_room to increase your cycle gap or reduce max turns to stay within API limits." : "";
     const isClaude = model === "claude" || model.startsWith("claude-");
     const toolCallInstruction = isClaude ? "Always call tools to take action \u2014 do not just describe what you would do." : "IMPORTANT: You MUST call at least one tool in your response. Respond ONLY with a tool call \u2014 do not write explanatory text without a tool call.";
-    const commsTools = isCli ? "quoroom_inbox_send_keeper (message keeper), quoroom_inbox_list (inter-room), quoroom_inbox_send_room, quoroom_inbox_reply" : "quoroom_ask_keeper";
-    const webTools = isCli ? "(use your built-in web search and fetch tools)" : "quoroom_web_search, quoroom_web_fetch, quoroom_browser";
-    const toolList = `**Goals:** quoroom_set_goal, quoroom_update_progress, quoroom_create_subgoal, quoroom_complete_goal, quoroom_abandon_goal
-**Governance:** quoroom_propose, quoroom_vote
-**Workers:** quoroom_create_worker, quoroom_update_worker
-**Tasks:** quoroom_schedule
-**Memory:** quoroom_remember, quoroom_recall
-**Web:** ${webTools}
-**Comms:** ${commsTools}
-**Settings:** quoroom_configure_room${selfRegulateHint}`;
-    const sendKeeperTool = isCli ? "quoroom_inbox_send_keeper" : "quoroom_ask_keeper";
+    const allowListRaw = status2.room.allowedTools?.trim() || null;
+    const allowSet = allowListRaw ? new Set(allowListRaw.split(",").map((s) => s.trim())) : null;
+    const has = (name) => !allowSet || allowSet.has(name);
+    const toolLines = [];
+    const goalTools = ["quoroom_set_goal", "quoroom_update_progress", "quoroom_create_subgoal", "quoroom_delegate_task", "quoroom_complete_goal", "quoroom_abandon_goal"].filter(has);
+    if (goalTools.length) toolLines.push(`**Goals:** ${goalTools.join(", ")}`);
+    const govTools = ["quoroom_propose", "quoroom_vote"].filter(has);
+    if (govTools.length) toolLines.push(`**Governance:** ${govTools.join(", ")}`);
+    const workerTools = ["quoroom_create_worker", "quoroom_update_worker"].filter(has);
+    if (workerTools.length) toolLines.push(`**Workers:** ${workerTools.join(", ")}`);
+    if (has("quoroom_schedule")) toolLines.push("**Tasks:** quoroom_schedule");
+    const memTools = ["quoroom_remember", "quoroom_recall"].filter(has);
+    if (memTools.length) toolLines.push(`**Memory:** ${memTools.join(", ")}`);
+    const walletToolNames = isCli ? ["quoroom_wallet_balance", "quoroom_wallet_send", "quoroom_wallet_history", "quoroom_wallet_topup"] : ["quoroom_wallet_balance", "quoroom_wallet_send", "quoroom_wallet_history"];
+    const filteredWallet = walletToolNames.filter(has);
+    if (filteredWallet.length) toolLines.push(`**Wallet:** ${filteredWallet.join(", ")}`);
+    const webToolNames = isCli ? null : ["quoroom_web_search", "quoroom_web_fetch", "quoroom_browser"];
+    if (isCli) {
+      if (has("quoroom_web_search") || has("quoroom_web_fetch")) toolLines.push("**Web:** (use your built-in web search and fetch tools)");
+    } else {
+      const filteredWeb = (webToolNames || []).filter(has);
+      if (filteredWeb.length) toolLines.push(`**Web:** ${filteredWeb.join(", ")}`);
+    }
+    const commsToolNames = isCli ? ["quoroom_send_message", "quoroom_inbox_list", "quoroom_inbox_send_room", "quoroom_inbox_reply"] : ["quoroom_send_message"];
+    const filteredComms = commsToolNames.filter(has);
+    if (filteredComms.length) {
+      if (isCli) toolLines.push(`**Comms:** ${filteredComms.map((t) => t === "quoroom_send_message" ? `${t} (message keeper or worker)` : t === "quoroom_inbox_list" ? `${t} (inter-room)` : t).join(", ")}`);
+      else toolLines.push(`**Comms:** ${filteredComms.join(", ")}`);
+    }
+    if (has("quoroom_configure_room")) toolLines.push(`**Settings:** quoroom_configure_room${selfRegulateHint}`);
+    const toolList = toolLines.join("\n");
     contextParts.push(`## Instructions
 Based on the current state, decide what to do next and call the appropriate tools. Available tools:
 
 ${toolList}
 
-Do NOT "stand by" or wait for anyone \u2014 every cycle must make progress. Act autonomously: make decisions and execute. Inform the keeper of progress or important updates using ${sendKeeperTool}, but never block on a response. If the keeper hasn't replied, proceed with your best judgment.
+Do NOT "stand by" or wait for anyone \u2014 every cycle must make progress. Act autonomously: make decisions and execute. Inform the keeper of progress or important updates using quoroom_send_message (to="keeper"), but never block on a response. If the keeper hasn't replied, proceed with your best judgment.
+
+Revenue is always a priority. Every room must sustain itself financially. Actively seek ways to earn: offer services to the keeper, propose paid work to other rooms, or find monetizable opportunities in your domain. Check your wallet balance and report financial status to the keeper.
 
 ${toolCallInstruction}`);
     const prompt = contextParts.join("\n\n");
@@ -25117,8 +25437,9 @@ ${toolCallInstruction}`);
     logBuffer.flush();
     const apiKey = apiKeyEarly;
     const needsQueenTools = model === "openai" || model.startsWith("openai:") || model === "anthropic" || model.startsWith("anthropic:") || model.startsWith("claude-api:");
+    const filteredToolDefs = allowSet ? QUEEN_TOOL_DEFINITIONS.filter((t) => allowSet.has(t.function.name)) : QUEEN_TOOL_DEFINITIONS;
     const apiToolOpts = needsQueenTools ? {
-      toolDefs: QUEEN_TOOL_DEFINITIONS,
+      toolDefs: filteredToolDefs,
       onToolCall: async (toolName, args) => {
         logBuffer.addSynthetic("tool_call", `\u2192 ${toolName}(${JSON.stringify(args)})`);
         const result2 = await executeQueenTool(db2, roomId, worker.id, toolName, args);
@@ -25134,6 +25455,8 @@ ${toolCallInstruction}`);
       timeoutMs: 5 * 60 * 1e3,
       maxTurns: maxTurns ?? 10,
       onConsoleLog: logBuffer.onConsoleLog,
+      // CLI models: block non-quoroom MCP tools (daymon, etc.)
+      disallowedTools: isCli ? "mcp__daymon*" : void 0,
       // CLI models: pass resumeSessionId for native --resume
       resumeSessionId,
       // API models: pass conversation history + persistence callback
@@ -25148,6 +25471,23 @@ ${toolCallInstruction}`);
     if (rateLimitInfo) {
       throw new RateLimitError(rateLimitInfo);
     }
+    if (result.exitCode !== 0) {
+      const errorDetail = result.output?.trim() || `exit code ${result.exitCode}`;
+      logBuffer.addSynthetic("error", `Agent execution failed: ${errorDetail.slice(0, 500)}`);
+      logBuffer.flush();
+      completeWorkerCycle(db2, cycle.id, errorDetail.slice(0, 500), result.usage);
+      options?.onCycleLifecycle?.("failed", cycle.id, roomId);
+      logRoomActivity(
+        db2,
+        roomId,
+        "error",
+        `Agent cycle failed (${worker.name}): ${errorDetail.slice(0, 200)}`,
+        errorDetail,
+        worker.id
+      );
+      updateAgentState(db2, worker.id, "idle");
+      return result.output;
+    }
     if (isCli && result.sessionId) {
       saveAgentSession(db2, worker.id, { sessionId: result.sessionId, model });
     }
@@ -25556,6 +25896,7 @@ function registerRoomRoutes(router) {
       const trimmed = body.queenNickname.trim().replace(/\s+/g, "");
       if (trimmed.length > 0 && trimmed.length <= 40) updates.queenNickname = trimmed;
     }
+    if (body.allowedTools !== void 0) updates.allowedTools = body.allowedTools || null;
     if (body.config !== void 0 && typeof body.config === "object" && body.config !== null) {
       updates.config = { ...room.config, ...body.config };
     }
@@ -25621,7 +25962,7 @@ function registerRoomRoutes(router) {
     if (!room) return { status: 404, error: "Room not found" };
     if (!room.queenWorkerId) return { status: 404, error: "No queen worker" };
     const worker = getWorker(ctx.db, room.queenWorkerId);
-    const model = worker?.model ?? null;
+    const model = worker?.model ?? room.workerModel ?? null;
     const auth = await getModelAuthStatus(ctx.db, roomId, model);
     return {
       data: {
@@ -25745,6 +26086,29 @@ function registerWorkerRoutes(router) {
     eventBus.emit("workers", "worker:deleted", { id });
     return { data: { ok: true } };
   });
+  router.post("/api/workers/:id/start", (ctx) => {
+    const id = Number(ctx.params.id);
+    const worker = getWorker(ctx.db, id);
+    if (!worker) return { status: 404, error: "Worker not found" };
+    if (!worker.roomId) return { status: 400, error: "Worker has no room" };
+    const room = getRoom(ctx.db, worker.roomId);
+    if (!room) return { status: 404, error: "Room not found" };
+    if (room.status !== "active") return { status: 400, error: "Room is not active" };
+    triggerAgent(ctx.db, worker.roomId, id, {
+      onCycleLogEntry: (entry) => eventBus.emit(`cycle:${entry.cycleId}`, "cycle:log", entry),
+      onCycleLifecycle: (event, cycleId) => eventBus.emit(`room:${worker.roomId}`, `cycle:${event}`, { cycleId, roomId: worker.roomId })
+    });
+    eventBus.emit("workers", "worker:started", { id, roomId: worker.roomId });
+    return { data: { ok: true, running: true } };
+  });
+  router.post("/api/workers/:id/stop", (ctx) => {
+    const id = Number(ctx.params.id);
+    const worker = getWorker(ctx.db, id);
+    if (!worker) return { status: 404, error: "Worker not found" };
+    pauseAgent(ctx.db, id);
+    eventBus.emit("workers", "worker:stopped", { id });
+    return { data: { ok: true, running: false } };
+  });
   router.get("/api/rooms/:roomId/workers", (ctx) => {
     const workers = listRoomWorkers(ctx.db, Number(ctx.params.roomId));
     return { data: workers };
@@ -28047,7 +28411,15 @@ function registerChatRoutes(router) {
       // 3 minutes
     });
     if (result.exitCode !== 0 || result.timedOut) {
-      const reason = result.output?.trim() || (result.timedOut ? "Chat request timed out" : "Chat execution failed");
+      const rawOutput = result.output?.trim();
+      let reason;
+      if (result.timedOut) {
+        reason = "Chat request timed out";
+      } else if (rawOutput) {
+        reason = rawOutput;
+      } else {
+        reason = `Chat execution failed (model: ${model}, exit code: ${result.exitCode})`;
+      }
       return { status: result.timedOut ? 504 : 502, error: reason.slice(0, 500) };
     }
     const response = result.output || "No response";
@@ -28134,6 +28506,7 @@ CREATE TABLE IF NOT EXISTS rooms (
     queen_nickname TEXT,
     chat_session_id TEXT,
     referred_by_code TEXT,
+    allowed_tools TEXT,
     created_at DATETIME DEFAULT (datetime('now','localtime')),
     updated_at DATETIME DEFAULT (datetime('now','localtime'))
 );
@@ -28618,6 +28991,13 @@ function runMigrations(database, log = console.log) {
     database.exec(`ALTER TABLE workers ADD COLUMN max_turns INTEGER`);
     log("Migrated: added cycle_gap_ms and max_turns columns to workers");
   }
+  const hasRoomAllowedTools = database.prepare(
+    `SELECT name FROM pragma_table_info('rooms') WHERE name='allowed_tools'`
+  ).get()?.name;
+  if (!hasRoomAllowedTools) {
+    database.exec(`ALTER TABLE rooms ADD COLUMN allowed_tools TEXT`);
+    log("Migrated: added allowed_tools column to rooms");
+  }
   const ollamaWorkers = database.prepare(`SELECT id FROM workers WHERE model LIKE 'ollama:%'`).all();
   if (ollamaWorkers.length > 0) {
     database.prepare(`UPDATE workers SET model = 'claude' WHERE model LIKE 'ollama:%'`).run();
@@ -28835,7 +29215,7 @@ function semverGt(a, b) {
 }
 function getCurrentVersion() {
   try {
-    return true ? "0.1.21" : null.version;
+    return true ? "0.1.23" : null.version;
   } catch {
     return "0.0.0";
   }
@@ -28992,7 +29372,7 @@ var cachedVersion = null;
 function getVersion3() {
   if (cachedVersion) return cachedVersion;
   try {
-    cachedVersion = true ? "0.1.21" : null.version;
+    cachedVersion = true ? "0.1.23" : null.version;
   } catch {
     cachedVersion = "unknown";
   }
@@ -29659,6 +30039,12 @@ function registerRoomMessageRoutes(router) {
     if (!msg) return { status: 404, error: "Message not found" };
     return { data: msg };
   });
+  router.post("/api/rooms/:roomId/messages/read-all", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const count = markAllRoomMessagesRead(ctx.db, roomId);
+    if (count > 0) eventBus.emit(`room:${roomId}`, "room_message:updated", { roomId, allRead: true });
+    return { data: { ok: true, count } };
+  });
   router.post("/api/rooms/:roomId/messages/:id/read", (ctx) => {
     const roomId = Number(ctx.params.roomId);
     const id = Number(ctx.params.id);