@rubytech/taskmaster 1.16.3 → 1.17.4

package/dist/hooks/bundled/ride-dispatch/handler.js

@@ -86,25 +86,54 @@ function extractPeerFromSessionKey(sessionKey) {
     return null;
 }
 /**
- * Find the admin agent ID from config.
- * The admin agent is the one marked `default: true`.
+ * Find the sibling admin agent for a given public agent.
+ *
+ * Convention: if the public agent is `beagle-zanzibar-public`, the admin is
+ * `beagle-zanzibar-admin`. Falls back to any admin agent that shares the same
+ * Beagle prefix, then the global default.
  */
-function findAdminAgentId(cfg) {
+function findSiblingAdminAgentId(cfg, publicAgentId) {
     const agents = cfg.agents?.list ?? [];
+    // Derive sibling: beagle-zanzibar-public → beagle-zanzibar-admin
+    if (publicAgentId.endsWith("-public")) {
+        const siblingId = publicAgentId.replace(/-public$/, "-admin");
+        if (agents.some((a) => a.id === siblingId))
+            return siblingId;
+    }
+    // Fallback: any admin agent sharing a Beagle prefix
+    const prefix = publicAgentId.replace(/-public$/, "");
+    const match = agents.find((a) => a.id?.startsWith(prefix) && a.id?.endsWith("-admin"));
+    if (match?.id)
+        return match.id;
+    // Last resort: global default
     const admin = agents.find((a) => a.default === true);
     if (admin?.id)
         return admin.id;
-    const defaultId = resolveDefaultAgentId(cfg);
-    return defaultId || null;
+    return resolveDefaultAgentId(cfg) || null;
+}
+/**
+ * Find the admin agent for a given account ID (used by payment webhooks
+ * where there's no public agent context). Convention: accountId
+ * "beagle-zanzibar" → admin agent "beagle-zanzibar-admin".
+ */
+function findAdminAgentForAccount(cfg, accountId) {
+    const agents = cfg.agents?.list ?? [];
+    const candidateId = `${accountId}-admin`;
+    if (agents.some((a) => a.id === candidateId))
+        return candidateId;
+    // Fallback: any admin agent whose ID starts with the account prefix
+    const match = agents.find((a) => a.id?.startsWith(accountId) && a.id?.endsWith("-admin"));
+    if (match?.id)
+        return match.id;
+    return resolveDefaultAgentId(cfg) || null;
 }
 /** Check if an agent ID belongs to a Beagle instance. */
 function isBeagleAgent(agentId) {
     return Boolean(agentId && agentId.toLowerCase().includes("beagle"));
 }
-/** Check if an agent is the public (non-admin) agent. */
-function isPublicAgentConfig(cfg, agentId) {
-    const agent = cfg.agents?.list?.find((a) => a.id === agentId);
-    return agent?.default !== true;
+/** Check if an agent is a public (non-admin) agent by naming convention. */
+function isPublicAgent(agentId) {
+    return agentId.endsWith("-public");
 }
 /**
  * Read the active negotiation index file for a driver phone.
@@ -140,6 +169,7 @@ async function dispatchToAdmin(params) {
         agentId: adminAgentId,
         channel: "system",
         peer: { kind: "dm", id: `ride-${jobId.toLowerCase()}` },
+        dmScope: "per-peer",
     }).toLowerCase();
     const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
     const envelope = formatInboundEnvelope({
@@ -189,7 +219,7 @@ async function dispatchToAdmin(params) {
 // ---------------------------------------------------------------------------
 // Build instruction text for each dispatch phase
 // ---------------------------------------------------------------------------
-function buildTripRequestInstruction(fields) {
+function buildTripRequestInstruction(fields, resolvedAccountId) {
     const jobId = fields.job_id ?? "UNKNOWN";
     const touristPhone = fields.tourist_phone ?? "unknown";
     const touristName = fields.tourist_name ?? "Tourist";
@@ -201,7 +231,7 @@ function buildTripRequestInstruction(fields) {
     const luggage = fields.luggage ?? "none";
     const specialRequests = fields.special_requests ?? "none";
     const fareEstimate = fields.fare_estimate ?? "unknown";
-    const accountId = fields.account_id ?? "default";
+    const accountId = resolvedAccountId;
     return (`[System: Ride Dispatch — Trip Request]\n\n` +
         `A tourist has requested a ride. Process this by contacting available drivers.\n\n` +
         `Job ID: ${jobId}\n` +
@@ -223,20 +253,23 @@ function buildTripRequestInstruction(fields) {
         `4. For each selected driver, update their status to awaiting_response via memory_write\n` +
         `5. Write shared/active-negotiations/{driver-phone}.md with job_id: ${jobId} for each driver\n` +
         `6. Message each driver in Swahili with the route details, pickup time, passengers, and job ID [${jobId}]\n` +
-        `   Use the message tool with accountId: "${accountId}"\n` +
+        `   Use the message tool with channel: "whatsapp", accountId: "${accountId}"\n` +
         `7. Message the tourist at ${touristPhone} confirming you've contacted drivers and are waiting for quotes\n` +
-        `   Use the message tool with accountId: "${accountId}"\n` +
+        `   Use the message tool with channel: "whatsapp", accountId: "${accountId}"\n` +
         `8. When drivers reply with quotes (dispatched to this session), compile the offers\n` +
-        `9. Message the tourist with up to 3 competing offers: fare, driver rating, vehicle type, estimated journey time\n` +
-        `   Do NOT reveal driver name, phone, or plate — those are gated by payment\n`);
+        `9. Message the tourist at ${touristPhone} with up to 3 competing offers: fare, vehicle type, driver rating, estimated journey time\n` +
+        `   Use the message tool with channel: "whatsapp", accountId: "${accountId}"\n` +
+        `   Cross-agent echo will relay the message to the tourist's active session automatically\n` +
+        `   Do NOT reveal driver name, phone, or plate — those are gated by payment\n` +
+        `   NOTE: Do NOT write a dispatch file for the offers — message the tourist directly\n`);
 }
-function buildBookingConfirmInstruction(fields) {
+function buildBookingConfirmInstruction(fields, resolvedAccountId) {
     const jobId = fields.job_id ?? "UNKNOWN";
     const touristPhone = fields.tourist_phone ?? "unknown";
     const driverName = fields.driver_name ?? "unknown";
     const driverPhone = fields.driver_phone ?? "unknown";
     const fare = fields.fare ?? "unknown";
-    const accountId = fields.account_id ?? "default";
+    const accountId = resolvedAccountId;
     return (`[System: Ride Dispatch — Booking Confirmation]\n\n` +
         `The tourist has selected a driver. Generate a Stripe payment link and send it.\n\n` +
         `Job ID: ${jobId}\n` +
@@ -248,7 +281,7 @@ function buildBookingConfirmInstruction(fields) {
         `1. Load the stripe skill and generate a Checkout Session for the booking fee\n` +
         `   Set metadata: booking_id="${jobId}", tourist_phone="${touristPhone}"\n` +
         `2. Message the tourist at ${touristPhone} with the payment link and booking terms\n` +
-        `   Use the message tool with accountId: "${accountId}"\n` +
+        `   Use the message tool with channel: "whatsapp", accountId: "${accountId}"\n` +
         `3. Record the booking details in shared/bookings/${jobId}.md via memory_write\n` +
         `4. Clear the active negotiation files for drivers NOT selected (delete their shared/active-negotiations/{phone}.md)\n`);
 }
@@ -263,9 +296,9 @@ function buildPaymentConfirmedInstruction(params) {
         `1. Read the booking record at shared/bookings/${bookingId}.md for driver details\n` +
         `2. Generate the pickup PIN and QR code (see references/pin-qr.md)\n` +
         `3. Message the tourist at ${touristPhone} with: driver name, phone, vehicle details, plate, and pickup PIN\n` +
-        `   Use the message tool with accountId: "${accountId}"\n` +
+        `   Use the message tool with channel: "whatsapp", accountId: "${accountId}"\n` +
         `4. Message the driver with: passenger name, pickup time/location, fare, and QR code URL\n` +
-        `   Use the message tool with accountId: "${accountId}"\n` +
+        `   Use the message tool with channel: "whatsapp", accountId: "${accountId}"\n` +
         `5. Update the booking record status to "confirmed"\n` +
         `6. Clear the active negotiation file for the driver (shared/active-negotiations/{phone}.md)\n`);
 }
@@ -290,8 +323,8 @@ async function handleMemoryAdd(event) {
         return;
     const jobId = match[1]; // e.g. BGL-0042
     const phase = match[2]; // trip-request | booking-confirm
-    // Dedup
-    const dedupKey = `dispatch:${relativePath}`;
+    // Dedup (use jobId+phase, not relativePath, since multiple watchers report different paths)
+    const dedupKey = `dispatch:${jobId}:${phase}`;
     if (isDuplicate(dedupKey))
         return;
     // Read the dispatch file
@@ -307,6 +340,10 @@ async function handleMemoryAdd(event) {
         return;
     }
     const fields = parseDispatchFile(content);
+    // Normalize: public agents may write tourist_id instead of tourist_phone
+    if (!fields.tourist_phone && fields.tourist_id) {
+        fields.tourist_phone = fields.tourist_id;
+    }
     // Load config (memory:add events don't carry cfg)
     let cfg;
     try {
@@ -317,18 +354,21 @@ async function handleMemoryAdd(event) {
         console.warn("[ride-dispatch] Could not read config");
         return;
     }
-    const adminAgentId = findAdminAgentId(cfg);
+    const adminAgentId = findSiblingAdminAgentId(cfg, agentId);
     if (!adminAgentId) {
-        console.warn("[ride-dispatch] No admin agent found in config");
+        console.warn("[ride-dispatch] No admin agent found for public agent:", agentId);
         return;
     }
-    const accountId = fields.account_id ?? resolveAgentBoundAccountId(cfg, agentId, "whatsapp") ?? "default";
+    // Resolve account: binding first, then derive from agent ID prefix
+    // (beagle-zanzibar-public → beagle-zanzibar), which matches WhatsApp account naming.
+    const accountId = resolveAgentBoundAccountId(cfg, agentId, "whatsapp") ??
+        (agentId.replace(/-(public|admin)$/, "") || "default");
     let instruction;
     if (phase === "trip-request") {
-        instruction = buildTripRequestInstruction(fields);
+        instruction = buildTripRequestInstruction(fields, accountId);
     }
     else if (phase === "booking-confirm") {
-        instruction = buildBookingConfirmInstruction(fields);
+        instruction = buildBookingConfirmInstruction(fields, accountId);
     }
     else {
         return;
@@ -347,7 +387,13 @@ async function handleMemoryAdd(event) {
     });
 }
 /**
- * Handle message:inbound events — driver replies routed to the public agent.
+ * Handle message:before-dispatch events — intercept driver replies before they
+ * reach the public agent's LLM.
+ *
+ * Sets event.suppress = true when the sender is a driver in active negotiation,
+ * then dispatches the reply to the admin agent's ride session instead.
+ * Because this handler is awaited by the caller, suppress takes effect before
+ * processForRoute is invoked.
  */
 async function handleDriverReply(event) {
     const context = event.context || {};
@@ -359,7 +405,7 @@ async function handleDriverReply(event) {
     const agentId = resolveAgentIdFromSessionKey(event.sessionKey);
     if (!agentId || !isBeagleAgent(agentId))
         return;
-    if (!isPublicAgentConfig(cfg, agentId))
+    if (!isPublicAgent(agentId))
         return;
     // Extract sender phone from session key
     const senderPhone = extractPeerFromSessionKey(event.sessionKey);
@@ -367,27 +413,38 @@ async function handleDriverReply(event) {
         return;
     // Resolve workspace dir from the agent config to find active-negotiations
     const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
-    // Check active negotiation index
+    // Check active negotiation index (synchronous — must complete before we return
+    // so that event.suppress is set before the caller checks it)
     const jobId = readActiveNegotiation(workspaceDir, senderPhone);
     if (!jobId)
-        return; // Not a driver in active negotiation
+        return; // Not a driver in active negotiation — let public agent handle it
+    // Suppress delivery to the public agent before doing anything else
+    event.suppress = true;
     // Dedup
     const dedupKey = `reply:${senderPhone}:${Date.now().toString().slice(0, -4)}`; // ~10s granularity
     if (isDuplicate(dedupKey))
         return;
-    const adminAgentId = findAdminAgentId(cfg);
+    const adminAgentId = findSiblingAdminAgentId(cfg, agentId);
     if (!adminAgentId)
         return;
-    const accountId = resolveAgentBoundAccountId(cfg, agentId, "whatsapp") ?? "default";
+    const accountId = resolveAgentBoundAccountId(cfg, agentId, "whatsapp") ??
+        (agentId.replace(/-(public|admin)$/, "") || "default");
     const instruction = `[System: Ride Dispatch — Driver Reply]\n\n` +
         `A driver has replied regarding job ${jobId}.\n\n` +
         `Driver phone: ${senderPhone}\n` +
         `Message: ${text}\n\n` +
         `Process this reply in the context of the ongoing negotiation for ${jobId}.\n` +
-        `If this is a fare quote, note it and compile offers when ready.\n` +
-        `If the driver is declining, update their status and active negotiation index.\n`;
+        `If this is a fare quote:\n` +
+        `  - Record the quote in the driver's memory profile\n` +
+        `  - When all expected quotes are in (or after a reasonable wait), compile the offers\n` +
+        `  - Message the tourist directly using the message tool with the compiled offers\n` +
+        `    The tourist phone is in the earlier trip-request message in this session\n` +
+        `    Use the message tool with channel: "whatsapp", accountId: "${accountId}"\n` +
+        `    Do NOT write a dispatch file — use the message tool to send the offers directly\n` +
+        `    Cross-agent echo will relay it to the tourist's active session automatically\n` +
+        `If the driver is declining, update their status in memory and delete their shared/active-negotiations/{phone-digits}.md file.\n`;
     console.log(`[ride-dispatch] Driver reply from ${senderPhone} for ${jobId}, dispatching to admin agent "${adminAgentId}"`);
-    // Fire and forget
+    // Fire and forget — suppress is already set, caller will skip processForRoute
     dispatchToAdmin({
         cfg,
         adminAgentId,
@@ -420,9 +477,11 @@ export async function dispatchPaymentConfirmed(params) {
         console.warn("[ride-dispatch] Could not read config for payment dispatch");
         return;
     }
-    const adminAgentId = findAdminAgentId(cfg);
+    // Payment webhooks don't have a public agent context. Derive admin from
+    // the accountId (e.g. "beagle-zanzibar" → "beagle-zanzibar-admin").
+    const adminAgentId = findAdminAgentForAccount(cfg, accountId);
     if (!adminAgentId) {
-        console.warn("[ride-dispatch] No admin agent for payment dispatch");
+        console.warn("[ride-dispatch] No admin agent for payment dispatch, accountId:", accountId);
         return;
     }
     const instruction = buildPaymentConfirmedInstruction({ bookingId, touristPhone, accountId });
@@ -443,7 +502,7 @@ const handleRideDispatch = async (event) => {
     if (event.type === "memory" && event.action === "add") {
         await handleMemoryAdd(event);
     }
-    else if (event.type === "message" && event.action === "inbound") {
+    else if (event.type === "message" && event.action === "before-dispatch") {
         await handleDriverReply(event);
     }
 };

package/dist/memory/manager.js

@@ -538,7 +538,7 @@ export class MemoryIndexManager {
         return this.syncing;
     }
     async readFile(params) {
-        const relPath = ensureMemoryPrefix(normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(normalizeRelPath(params.relPath))));
+        const relPath = normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(ensureMemoryPrefix(normalizeRelPath(params.relPath))));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error(relPath
                 ? `invalid path "${relPath}" — must start with "memory/" (e.g. "memory/admin/file.md")`
@@ -578,7 +578,7 @@ export class MemoryIndexManager {
      * matching the session's scope configuration.
      */
     async writeFile(params) {
-        const relPath = ensureMemoryPrefix(normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(normalizeRelPath(params.relPath))));
+        const relPath = normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(ensureMemoryPrefix(normalizeRelPath(params.relPath))));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error(relPath
                 ? `invalid path "${relPath}" — must start with "memory/" (e.g. "memory/admin/file.md")`
@@ -626,7 +626,7 @@ export class MemoryIndexManager {
         let relPath;
         if (params.destFolder) {
             // Explicit folder — use as-is (scope checking enforces access)
-            relPath = normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(`${params.destFolder}/${params.destFilename}`));
+            relPath = normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(ensureMemoryPrefix(`${params.destFolder}/${params.destFilename}`)));
         }
         else {
             // Default: memory/users/{peer}/media/{filename}

package/dist/tui/tui-command-handlers.js

@@ -363,7 +363,7 @@ export function createCommandHandlers(context) {
                 try {
                     await client.patchSession({
                         key: state.currentSessionKey,
-                        groupActivation: args === "always" ? "always" : "mention",
+                        groupActivation: args === "always" ? "always" : args === "off" ? "off" : "mention",
                     });
                     chatLog.addSystem(`activation set to ${args}`);
                     await refreshSessionInfo();

package/dist/web/auto-reply/monitor/group-activation.js

@@ -1,6 +1,5 @@
-import { normalizeGroupActivation } from "../../../auto-reply/group-activation.js";
-import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention, } from "../../../config/group-policy.js";
-import { loadSessionStore, resolveGroupSessionKey, resolveStorePath, } from "../../../config/sessions.js";
+import { resolveChannelGroupActivation, resolveChannelGroupPolicy, resolveChannelGroupRequireMention, } from "../../../config/group-policy.js";
+import { resolveGroupSessionKey } from "../../../config/sessions.js";
 export function resolveGroupPolicyFor(cfg, conversationId) {
     const groupId = resolveGroupSessionKey({
         From: conversationId,
@@ -26,12 +25,15 @@ export function resolveGroupRequireMentionFor(cfg, conversationId) {
     });
 }
 export function resolveGroupActivationFor(params) {
-    const storePath = resolveStorePath(params.cfg.session?.store, {
-        agentId: params.agentId,
+    const groupId = resolveGroupSessionKey({
+        From: params.conversationId,
+        ChatType: "group",
+        Provider: "whatsapp",
+    })?.id;
+    const configActivation = resolveChannelGroupActivation({
+        cfg: params.cfg,
+        channel: "whatsapp",
+        groupId: groupId ?? params.conversationId,
     });
-    const store = loadSessionStore(storePath);
-    const entry = store[params.sessionKey];
-    const requireMention = resolveGroupRequireMentionFor(params.cfg, params.conversationId);
-    const defaultActivation = requireMention === false ? "always" : "mention";
-    return normalizeGroupActivation(entry?.groupActivation) ?? defaultActivation;
+    return configActivation ?? "mention";
 }

package/dist/web/auto-reply/monitor/group-gating.js

@@ -58,6 +58,10 @@ export function applyGroupGating(params) {
         sessionKey: params.sessionKey,
         conversationId: params.conversationId,
     });
+    if (activation === "off") {
+        params.logVerbose(`Group ${params.conversationId} activation=off, ignoring`);
+        return { shouldProcess: false };
+    }
     const requireMention = activation !== "always";
     const selfJid = params.msg.selfJid?.replace(/:\\d+/, "");
     const replySenderJid = params.msg.replyToSenderJid?.replace(/:\\d+/, "");
@@ -76,8 +80,25 @@ export function applyGroupGating(params) {
     });
     params.msg.wasMentioned = mentionGate.effectiveWasMentioned;
     if (!shouldBypassMention && requireMention && mentionGate.shouldSkip) {
-        params.logVerbose(`Group message (no mention) — agent will process silently in ${params.conversationId}: ${params.msg.body}`);
-        return { shouldProcess: true, mentionGated: true };
+        params.logVerbose(`Group message (no mention) — accumulating context only in ${params.conversationId}: ${params.msg.body}`);
+        // Record the un-mentioned message in the group history buffer so it is
+        // available as context when the bot is eventually @mentioned.
+        const sender = params.msg.senderName && params.msg.senderE164
+            ? `${params.msg.senderName} (${params.msg.senderE164})`
+            : (params.msg.senderName ?? params.msg.senderE164 ?? "Unknown");
+        recordPendingHistoryEntryIfEnabled({
+            historyMap: params.groupHistories,
+            historyKey: params.groupHistoryKey,
+            limit: params.groupHistoryLimit,
+            entry: {
+                sender,
+                body: params.msg.body,
+                timestamp: params.msg.timestamp,
+                id: params.msg.id,
+                senderJid: params.msg.senderJid,
+            },
+        });
+        return { shouldProcess: true, contextOnly: true };
     }
     return { shouldProcess: true };
 }

package/dist/web/auto-reply/monitor/on-message.js

@@ -1,3 +1,4 @@
+import { loadConfig } from "../../../config/config.js";
 import { logVerbose } from "../../../globals.js";
 import { isLicensed } from "../../../license/state.js";
 import { createInternalHookEvent, triggerInternalHook } from "../../../hooks/internal-hooks.js";
@@ -29,7 +30,7 @@ export function createWebOnMessageHandler(params) {
         buildCombinedEchoKey: params.echoTracker.buildCombinedKey,
         groupHistory: opts?.groupHistory,
         suppressGroupHistoryClear: opts?.suppressGroupHistoryClear,
-        suppressDelivery: opts?.suppressDelivery,
+        contextOnly: opts?.contextOnly,
     });
     return async (msg) => {
         // Block all message processing when unlicensed.
@@ -40,8 +41,12 @@ export function createWebOnMessageHandler(params) {
         logVerbose(`[on-message] processing message from=${msg.from} body=${msg.body?.slice(0, 60)}`);
         const conversationId = msg.conversationId ?? msg.from;
         const peerId = resolvePeerId(msg);
+        // Read config fresh for routing so that binding changes (e.g. admin revocation)
+        // take effect on the next message without requiring a channel restart.
+        // `loadConfig()` has a 200ms cache so this is cheap under normal message rates.
+        const routingCfg = loadConfig();
         const route = resolveAgentRoute({
-            cfg: params.cfg,
+            cfg: routingCfg,
             channel: "whatsapp",
             accountId: msg.accountId,
             peer: {
@@ -67,7 +72,7 @@ export function createWebOnMessageHandler(params) {
             params.echoTracker.forget(msg.body);
             return;
         }
-        let mentionGated = false;
+        let contextOnly = false;
         if (msg.chatType === "group") {
             const metaCtx = {
                 From: msg.from,
@@ -132,7 +137,7 @@ export function createWebOnMessageHandler(params) {
                 }
                 return;
             }
-            mentionGated = gating.mentionGated ?? false;
+            contextOnly = gating.contextOnly ?? false;
         }
         else {
             // Ensure `peerId` for DMs is stable and stored as E.164 when possible.
@@ -153,8 +158,25 @@ export function createWebOnMessageHandler(params) {
         })) {
             return;
         }
+        // Fire message:before-dispatch awaited so hooks can suppress processing.
+        // Unlike message:inbound (fire-and-forget inside processMessage), this is
+        // awaited here, allowing a handler to set event.suppress = true before
+        // the public agent's LLM is invoked. Used by ride-dispatch to intercept
+        // driver replies and route them to the admin agent instead.
+        const beforeDispatch = createInternalHookEvent("message", "before-dispatch", route.sessionKey, {
+            from: msg.senderE164 ?? msg.from,
+            to: msg.to,
+            text: msg.body,
+            chatType: msg.chatType,
+            agentId: route.agentId,
+            channel: "whatsapp",
+            cfg: params.cfg,
+        });
+        await triggerInternalHook(beforeDispatch);
+        if (beforeDispatch.suppress)
+            return;
         await processForRoute(msg, route, groupHistoryKey, {
-            suppressDelivery: mentionGated || undefined,
+            contextOnly: contextOnly || undefined,
         });
     };
 }

package/dist/web/auto-reply/monitor/process-message.js

@@ -182,10 +182,10 @@ export async function processMessage(params) {
     // ── End opening hours gate ──────────────────────────────────────────
     // Send ack reaction immediately upon message receipt (post-gating).
     // Suppress when running silently on un-mentioned group messages.
-    if (params.suppressDelivery) {
+    if (params.contextOnly) {
         shouldClearGroupHistory = false;
     }
-    if (!params.suppressDelivery)
+    if (!params.contextOnly)
         maybeSendAckReaction({
             cfg: params.cfg,
             msg: params.msg,
@@ -315,6 +315,21 @@ export async function processMessage(params) {
         }, "failed updating session meta");
     });
     trackBackgroundTask(params.backgroundTasks, metaTask);
+    // contextOnly mode: accumulate user message in transcript but skip LLM.
+    // This prevents phantom assistant messages that corrupt conversation history.
+    if (params.contextOnly) {
+        // Store user message in transcript so context accumulates for the next mentioned reply
+        void appendUserMessageToSessionTranscript({
+            agentId: params.route.agentId,
+            sessionKey: params.route.sessionKey,
+            text: combinedBody,
+            storePath,
+        }).catch((err) => {
+            params.replyLogger.warn({ error: formatError(err) }, "contextOnly: failed to store user turn");
+        });
+        params.replyLogger.info({ correlationId, from: fromDisplay }, "context-only mode: user message stored, LLM skipped");
+        return false;
+    }
     const { queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg: params.cfg,
@@ -328,60 +343,56 @@ export async function processMessage(params) {
                     logVerbose("Stripped stray HEARTBEAT_OK token from web reply");
                 }
             },
-            deliver: params.suppressDelivery
-                ? async () => {
-                    /* Silently discard — agent ran but reply is suppressed (no mention) */
+            deliver: async (payload, info) => {
+                await deliverWebReply({
+                    replyResult: payload,
+                    msg: params.msg,
+                    maxMediaBytes: params.maxMediaBytes,
+                    textLimit,
+                    chunkMode,
+                    replyLogger: params.replyLogger,
+                    connectionId: params.connectionId,
+                    // Tool + block updates are noisy; skip their log lines.
+                    skipLog: info.kind !== "final",
+                    tableMode,
+                });
+                didSendReply = true;
+                if (info.kind === "tool") {
+                    params.rememberSentText(payload.text, {});
+                    return;
                 }
-                : async (payload, info) => {
-                    await deliverWebReply({
-                        replyResult: payload,
-                        msg: params.msg,
-                        maxMediaBytes: params.maxMediaBytes,
-                        textLimit,
-                        chunkMode,
-                        replyLogger: params.replyLogger,
-                        connectionId: params.connectionId,
-                        // Tool + block updates are noisy; skip their log lines.
-                        skipLog: info.kind !== "final",
-                        tableMode,
-                    });
-                    didSendReply = true;
-                    if (info.kind === "tool") {
-                        params.rememberSentText(payload.text, {});
-                        return;
+                const shouldLog = info.kind === "final" && payload.text ? true : undefined;
+                params.rememberSentText(payload.text, {
+                    combinedBody,
+                    combinedBodySessionKey: params.route.sessionKey,
+                    logVerboseMessage: shouldLog,
+                });
+                if (info.kind === "final") {
+                    const fromDisplay = params.msg.chatType === "group" ? conversationId : (params.msg.from ?? "unknown");
+                    const hasMedia = Boolean(payload.mediaUrl || payload.mediaUrls?.length);
+                    whatsappOutboundLog.info(`Auto-replied to ${fromDisplay}${hasMedia ? " (media)" : ""}`);
+                    if (shouldLogVerbose()) {
+                        const preview = payload.text != null ? elide(payload.text, 400) : "<media>";
+                        whatsappOutboundLog.debug(`Reply body: ${preview}${hasMedia ? " (media)" : ""}`);
                     }
-                    const shouldLog = info.kind === "final" && payload.text ? true : undefined;
-                    params.rememberSentText(payload.text, {
-                        combinedBody,
-                        combinedBodySessionKey: params.route.sessionKey,
-                        logVerboseMessage: shouldLog,
+                    // Fire message:outbound hook for conversation archiving
+                    const outboundHookEvent = createInternalHookEvent("message", "outbound", params.route.sessionKey, {
+                        from: params.msg.to, // Agent is sending
+                        to: params.msg.senderE164 ?? params.msg.from, // To the user
+                        text: payload.text,
+                        timestamp: Date.now(),
+                        chatType: params.msg.chatType,
+                        agentId: params.route.agentId,
+                        channel: "whatsapp",
+                        hasMedia,
+                        senderE164: params.msg.senderE164,
+                        groupSubject: params.msg.groupSubject,
+                        conversationId,
+                        cfg: params.cfg,
                     });
-                    if (info.kind === "final") {
-                        const fromDisplay = params.msg.chatType === "group" ? conversationId : (params.msg.from ?? "unknown");
-                        const hasMedia = Boolean(payload.mediaUrl || payload.mediaUrls?.length);
-                        whatsappOutboundLog.info(`Auto-replied to ${fromDisplay}${hasMedia ? " (media)" : ""}`);
-                        if (shouldLogVerbose()) {
-                            const preview = payload.text != null ? elide(payload.text, 400) : "<media>";
-                            whatsappOutboundLog.debug(`Reply body: ${preview}${hasMedia ? " (media)" : ""}`);
-                        }
-                        // Fire message:outbound hook for conversation archiving
-                        const outboundHookEvent = createInternalHookEvent("message", "outbound", params.route.sessionKey, {
-                            from: params.msg.to, // Agent is sending
-                            to: params.msg.senderE164 ?? params.msg.from, // To the user
-                            text: payload.text,
-                            timestamp: Date.now(),
-                            chatType: params.msg.chatType,
-                            agentId: params.route.agentId,
-                            channel: "whatsapp",
-                            hasMedia,
-                            senderE164: params.msg.senderE164,
-                            groupSubject: params.msg.groupSubject,
-                            conversationId,
-                            cfg: params.cfg,
-                        });
-                        void triggerInternalHook(outboundHookEvent);
-                    }
-                },
+                    void triggerInternalHook(outboundHookEvent);
+                }
+            },
             onError: (err, info) => {
                 const label = info.kind === "tool"
                     ? "tool update"

package/dist/web/inbound/monitor.js

@@ -395,5 +395,35 @@ export async function monitorWebInbox(options) {
         },
         // IPC surface (sendMessage/sendPoll/sendReaction/sendComposingTo)
         ...sendApi,
+        // Conversation browser methods
+        listConversations: async () => {
+            const entries = [];
+            for (const [jid, cached] of groupMetaCache) {
+                entries.push({
+                    jid,
+                    type: "group",
+                    name: cached.subject ?? jid,
+                    lastMessageTimestamp: undefined,
+                });
+            }
+            return entries;
+        },
+        getMessages: async (_jid, _limit) => {
+            // No in-memory message store — Baileys makeInMemoryStore is not used.
+            return [];
+        },
+        getGroupMetadata: async (jid) => {
+            const meta = await sock.groupMetadata(jid);
+            return {
+                subject: meta.subject,
+                participants: (meta.participants ?? []).map((p) => ({
+                    jid: p.id,
+                    name: p.name ?? undefined,
+                    admin: p.admin === "admin" || p.admin === "superadmin",
+                })),
+                creation: meta.creation,
+                desc: meta.desc ?? undefined,
+            };
+        },
     };
 }

package/extensions/whatsapp/src/channel.ts

@@ -56,7 +56,7 @@ export const whatsappPlugin: ChannelPlugin<ResolvedWhatsAppAccount> = {
     reactions: true,
     media: true,
   },
-  reload: { configPrefixes: ["web"], noopPrefixes: ["channels.whatsapp"] },
+  reload: { configPrefixes: ["web", "channels.whatsapp"], noopPrefixes: [] },
   gatewayMethods: ["web.login.start", "web.login.wait"],
   configSchema: buildChannelConfigSchema(WhatsAppConfigSchema),
   config: {