@rubytech/taskmaster 1.16.3 → 1.17.0

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: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.16.3",
+  "version": "1.17.0",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"

package/skills/log-review/SKILL.md

@@ -20,12 +20,13 @@ Load `references/review-protocol.md` for the full review and analysis protocol.
 
 ### Rules
 
-1. **Scan system logs** — use `logs_read(action: "system")` for gateway-level errors and warnings
+1. **Scan system logs** — use `logs_read(action: "system", minLevel: "warn")` to retrieve only warnings and errors. Do not call without `minLevel` — full logs will overflow context.
 2. **Scan session logs** — use `logs_read(action: "sessions")` across all agents for tool failures and agent errors
 3. **Triage by severity** — critical, warning, info. Deduplicate repeated errors.
-4. **Analyse each issue** — plain-language explanation, likely root cause, suggested admin action
-5. **Escalation guidance** — for issues beyond local resolution, advise forwarding this report to the Taskmaster public agent on WhatsApp for support
-6. **All-clear confirmation** — if no issues found, confirm briefly so admins know the review ran
+4. **Deduplicate** — group identical messages from repeated occurrences and report as "N× [message]" rather than listing each separately.
+5. **Analyse each issue** — plain-language explanation, likely root cause, suggested admin action
+6. **Escalation guidance** — for issues beyond local resolution, advise forwarding this report to the Taskmaster public agent on WhatsApp for support
+7. **All-clear confirmation** — if no issues found, confirm briefly so admins know the review ran
 
 ### Output Format
 
@@ -37,8 +38,20 @@ The report should follow this structure:
 - **Escalation** — if any issues warrant Taskmaster support, advise forwarding this report
 - **Summary** — issue count or all-clear confirmation
 
+Each individual issue entry must be formatted exactly as:
+
+```
+**N. Title** _(HH:MM or HH:MM–HH:MM Nx)_
+- What: ...
+- Why: ...
+- Action: ...
+```
+
+The time in parentheses is mandatory. Extract it from the log line's `time` field (UTC ISO format, e.g. `2026-03-05T10:35:22.000Z`) — take the `HH:MM` part, which is characters 11–15 of the string (e.g. `10:35`). For repeated occurrences show the first–last range and count: `08:36–09:48 (3×)`. Never omit the time — if the log line has no `time` field, write `(?:??)` as a placeholder.
+
 ### Constraints
 
+- **Only report what is directly evidenced in the log data returned by the tools.** Do not infer, extrapolate, or report issues that do not appear verbatim in the log lines. Every issue in the report must be traceable to a specific log entry you received.
 - Keep total execution under 2 minutes
 - Be honest — if nothing surfaced, say "all clear" rather than padding the report
 - Use plain language — the admin is not a developer

package/skills/log-review/references/review-protocol.md

@@ -4,9 +4,7 @@ Run this protocol on schedule or when triggered by an admin. Be thorough in anal
 
 ## Step 1: System Log Scan
 
-Use `logs_read` with `action: "system"` to pull recent gateway logs.
-
-Focus on entries containing `[ERROR]` and `[WARN]`. Ignore routine info-level entries unless they reveal a pattern (e.g. repeated restarts, auth refresh cycles).
+Use `logs_read(action: "system", minLevel: "warn")` to pull only warnings and errors. **Never call without `minLevel`** — the full log will overflow context.
 
 Look for:
 - Service crashes or unexpected restarts
@@ -18,7 +16,7 @@ Look for:
 
 ## Step 2: Session Log Scan
 
-Use `logs_read` with `action: "sessions"` to pull recent session transcripts across all agents.
+Use `logs_read(action: "sessions")` to pull recent error entries across all agents. Only error-type entries are returned — tool failures, agent exceptions, and crashed sessions.
 
 Look for:
 - Tool call failures or errors
@@ -46,6 +44,8 @@ For each issue provide:
 
 Be specific with actions. "Check the logs" is not a useful suggestion — the whole point of this skill is that the admin doesn't have to.
 
+**CRITICAL: Only report issues present in the log data you received.** Do not draw on your knowledge of the codebase, providers, or past conversations to invent or infer issues. If a provider name, error code, or warning does not appear in a log line you read, it must not appear in the report. Fabricating issues destroys trust.
+
 ## Step 5: Escalation Guidance
 
 If any issue meets these criteria, advise the admin to escalate to Taskmaster support:

package/taskmaster-docs/USER-GUIDE.md

@@ -1166,6 +1166,20 @@ Occasionally, AI providers like Claude experience temporary outages or slowdowns
 2. **Check your logs** — If replies are failing, open **Advanced → Logs → Session Logs** and filter by "errors" to see what's happening.
 3. **Wait it out** — Most AI service outages resolve within minutes to hours. Your assistant will automatically use the primary provider again once it's back.
 
+### Sharing logs with support
+
+If you're still stuck after trying the steps above, export your logs and send them to Taskmaster support on WhatsApp. Logs give the support team exact error messages and timing, which speeds up diagnosis.
+
+1. Go to the **Advanced** tab in the Control Panel and tap **Logs**
+2. Select the view that covers your issue:
+   - **Session Logs** — for problems with replies, conversations, or tool errors
+   - **System Logs** — for connection, startup, or gateway issues
+3. Tap **Filters** to open the filter panel
+4. Tap **Export** — the browser downloads a log file to your device
+5. Send the file to Taskmaster support on WhatsApp
+
+> **Tip:** If you're not sure which view to use, export both — Session Logs and System Logs — and send them together.
+
 ### "sudo: unable to resolve host taskmaster" warning?
 
 This harmless warning appears when the Pi's hostname isn't listed in `/etc/hosts`. Every `sudo` command still works — it's just a cosmetic message. To fix it, open a terminal on the Pi and run: