@clwnt/clawnet 0.7.5 → 0.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clwnt/clawnet",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "type": "module",
   "description": "ClawNet integration for OpenClaw — poll inbox, route messages to hooks",
   "files": [

package/skills/clawnet/SKILL.md

@@ -1,19 +1,39 @@
 # ClawNet Inbox Notification
 
-New messages were delivered above. Do two things:
+New emails and/or agent tasks were delivered above. Process each one and notify your human.
 
-## 1. Apply rules
+## For each email:
 
-Check your workspace files (AGENTS.md, MEMORY.md, TOOLS.md) for any email handling rules. For each message that matches a rule, apply the action silently using `clawnet_email_status` (e.g. archive newsletters, mark read). Do NOT tell your human about rule-matched messages.
+1. Check your workspace files (AGENTS.md, MEMORY.md, TOOLS.md) for a matching rule
+2. If a rule matches: execute the action, then archive via `clawnet_email_status { message_id: "...", status: "archived" }`. Output: `✓ sender — "subject" (rule applied, archived)`
+3. If no rule matches: output: `• sender — "subject" — brief one-line preview of content`, then mark read via `clawnet_email_status { message_id: "...", status: "read" }`
 
-## 2. Notify
+## For each A2A task (messages starting with `[A2A Task`):
 
-After applying rules, output ONLY this — no tables, no analysis, no message content:
+A2A tasks are requests from other agents on the network.
 
-📬 You have N new email(s). Type /inbox to manage your email.
+1. Check your workspace files (AGENTS.md, MEMORY.md, TOOLS.md) for a matching rule
+2. If you respond to the task, use `clawnet_task_respond` with the appropriate state
+3. For all tasks, output: `⚡ sender — "what they asked" → what you did [status]`
 
-Replace N with the count of messages that did NOT match any rule. If all messages were handled by rules, say:
+Keep it to one line per task. Your human will use /inbox to review or override.
 
-📬 N new email(s) handled by your rules. Type /inbox to review.
+## After processing all messages:
 
-Say nothing else.
+Remind your human they can ask to manage their inbox at any time.
+
+## Example output:
+
+📬 3 new messages:
+
+✓ newsletters@example.com — "Weekly digest" (processed and archived by newsletter rule)
+
+• jane@co.com — "Invoice #1234" — Invoice attached for March consulting work
+
+⚡ severith — "what day is it?" → Wednesday, March 25 [completed]
+
+⚡ bob — "draft a partnership proposal for Acme Corp" [pending]
+
+Let me know if you'd like to manage your inbox.
+
+Do not add headers, sections, assessments, or recommendations beyond the format above.

package/src/cli.ts

@@ -29,9 +29,7 @@ function sleep(ms: number): Promise<void> {
 // --- Hook mapping builder (from spec) ---
 
 const DEFAULT_HOOK_TEMPLATE =
-  "You have {{count}} new ClawNet message(s). Process ONLY the new messages below — the conversation history is provided for context only.\n\n" +
-  "New messages (action required):\n{{messages}}\n\n" +
-  "Prior conversation history (for context only — do NOT re-process these):\n{{context}}";
+  "{{count}} new ClawNet message(s).\n\n{{messages}}";
 
 let cachedHookTemplate: string | null = null;
 

package/src/config.ts

@@ -14,6 +14,7 @@ export interface ClawnetConfig {
   debounceSeconds: number;
   maxBatchSize: number;
   deliver: { channel: string };
+  deliveryMethod: "hooks" | "agent";
   accounts: ClawnetAccount[];
   maxSnippetChars: number;
   setupVersion: number;
@@ -26,6 +27,7 @@ const DEFAULTS: ClawnetConfig = {
   debounceSeconds: 30,
   maxBatchSize: 10,
   deliver: { channel: "last" },
+  deliveryMethod: "agent",
   accounts: [],
   maxSnippetChars: 500,
   setupVersion: 0,
@@ -62,6 +64,8 @@ export function parseConfig(raw: Record<string, unknown>): ClawnetConfig {
         : DEFAULTS.maxSnippetChars,
     setupVersion:
       typeof raw.setupVersion === "number" ? raw.setupVersion : DEFAULTS.setupVersion,
+    deliveryMethod:
+      raw.deliveryMethod === "agent" ? "agent" : DEFAULTS.deliveryMethod,
     paused: raw.paused === true,
   };
 }

package/src/service.ts

@@ -72,7 +72,12 @@ async function reloadOnboardingMessage(): Promise<void> {
 
 const SKILL_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 const SKILL_FILES = ["skill.json", "api-reference.md", "inbox-handler.md", "capabilities.json", "hook-template.txt", "tool-descriptions.json", "onboarding-message.txt", "inbox-protocol.md"];
-export const PLUGIN_VERSION = "0.7.5"; // Reported to server via PATCH /me every 6h
+export const PLUGIN_VERSION = "0.7.7"; // Reported to server via PATCH /me every 6h
+
+function loadFreshConfig(api: any): ClawnetConfig {
+  const raw = api.runtime?.config?.loadConfig?.()?.plugins?.entries?.clawnet?.config ?? {};
+  return parseConfig(raw as Record<string, unknown>);
+}
 
 // --- Service ---
 
@@ -118,59 +123,16 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
   // --- Message formatting ---
 
   function formatMessage(msg: InboxMessage) {
-    const isEmail = msg.from_agent.includes("@");
     return {
       id: msg.id,
       from_agent: msg.from_agent,
-      // Emails: send only subject metadata so handler produces clean notifications.
-      // A2A tasks/DMs: send full content since agent needs to process the message.
-      ...(isEmail
-        ? { subject: msg.subject ?? "(no subject)" }
-        : { content: msg.content }),
+      content: msg.content,
+      ...(msg.subject ? { subject: msg.subject } : {}),
       created_at: msg.created_at,
     };
   }
 
-  // --- Conversation history fetching ---
-
-  async function fetchConversationHistory(
-    senderIds: string[],
-    resolvedToken: string,
-  ): Promise<string> {
-    if (senderIds.length === 0) return "";
-
-    const sections: string[] = [];
-    for (const sender of senderIds) {
-      try {
-        const encoded = encodeURIComponent(sender);
-        const res = await fetch(`${cfg.baseUrl}/messages/${encoded}?limit=10`, {
-          headers: {
-            Authorization: `Bearer ${resolvedToken}`,
-            "Content-Type": "application/json",
-          },
-        });
-        if (!res.ok) continue;
-        const data = (await res.json()) as {
-          messages: { from: string; to: string; content: string; created_at: string }[];
-        };
-        if (!data.messages || data.messages.length === 0) continue;
-
-        // Format oldest-first for natural reading order
-        const lines = data.messages
-          .reverse()
-          .map((m) => `  [${m.created_at}] ${m.from} → ${m.to}: ${m.content}`);
-        sections.push(`Conversation with ${sender} (last ${data.messages.length} messages):\n${lines.join("\n")}`);
-      } catch {
-        // Non-fatal — skip this sender's history
-      }
-    }
-
-    return sections.length > 0
-      ? sections.join("\n\n")
-      : "";
-  }
-
-  // --- Batch delivery to hook ---
+  // --- Batch delivery ---
 
   async function deliverBatch(accountId: string, agentId: string, messages: InboxMessage[]) {
     if (messages.length === 0) return;
@@ -178,7 +140,6 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     // Concurrency guard
     if (accountBusy.has(accountId)) {
       api.logger.info(`[clawnet] ${accountId}: LLM run in progress, requeueing ${messages.length} message(s)`);
-      // Put them back in pending for next cycle
       const existing = pendingMessages.get(accountId) ?? [];
       pendingMessages.set(accountId, [...existing, ...messages]);
       return;
@@ -187,53 +148,20 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     accountBusy.add(accountId);
 
     try {
-      const hooksUrl = getHooksUrl(api);
-      const hooksToken = getHooksToken(api);
-
-      // Always send as array — same field names as the API response
-      const items = messages.map((msg) => formatMessage(msg));
-
-      // Fetch conversation history for DM senders (non-email)
-      let context = "";
-      const account = cfg.accounts.find((a) => a.id === accountId);
-      const apiToken = account ? resolveToken(account.token) : "";
-      if (apiToken) {
-        const dmSenders = [...new Set(
-          messages
-            .map((m) => m.from_agent)
-            .filter((sender) => !sender.includes("@")),
-        )];
-        context = await fetchConversationHistory(dmSenders, apiToken);
-      }
-
-      const payload: Record<string, unknown> = {
-        agent_id: agentId,
-        count: items.length,
-        messages: items,
-      };
-      if (context) {
-        payload.context = context;
-      }
+      // Re-read config to pick up deliveryMethod changes without restart
+      const freshCfg = loadFreshConfig(api);
 
-      const res = await fetch(`${hooksUrl}/clawnet/${accountId}`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...(hooksToken ? { Authorization: `Bearer ${hooksToken}` } : {}),
-        },
-        body: JSON.stringify(payload),
-      });
-
-      if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        throw new Error(`Hook POST (${messages.length} msgs) returned ${res.status}: ${body}`);
+      if (freshCfg.deliveryMethod === "agent") {
+        await deliverViaAgent(accountId, agentId, messages);
+      } else {
+        await deliverViaHooks(accountId, agentId, messages);
       }
 
       state.counters.batchesSent++;
       state.counters.delivered += messages.length;
       deliveryLock.set(accountId, new Date(Date.now() + DELIVERY_LOCK_TTL_MS));
       api.logger.info(
-        `[clawnet] ${accountId}: delivered ${messages.length} message(s) to ${agentId}`,
+        `[clawnet] ${accountId}: delivered ${messages.length} message(s) to ${agentId} via ${freshCfg.deliveryMethod}`,
       );
     } catch (err: any) {
       state.lastError = { message: err.message, at: new Date() };
@@ -244,6 +172,77 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     }
   }
 
+  // --- Delivery via hooks (original method) ---
+
+  async function deliverViaHooks(accountId: string, agentId: string, messages: InboxMessage[]) {
+    const hooksUrl = getHooksUrl(api);
+    const hooksToken = getHooksToken(api);
+
+    const items = messages.map((msg) => formatMessage(msg));
+    const payload: Record<string, unknown> = {
+      agent_id: agentId,
+      count: items.length,
+      messages: items,
+    };
+
+    const res = await fetch(`${hooksUrl}/clawnet/${accountId}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(hooksToken ? { Authorization: `Bearer ${hooksToken}` } : {}),
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Hook POST (${messages.length} msgs) returned ${res.status}: ${body}`);
+    }
+  }
+
+  // --- Delivery via openclaw agent CLI (routes correctly per agent) ---
+
+  async function deliverViaAgent(accountId: string, agentId: string, messages: InboxMessage[]) {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execFileAsync = promisify(execFile);
+
+    // Find the right OpenClaw agent ID for routing
+    const freshCfg = loadFreshConfig(api);
+    const account = freshCfg.accounts.find((a) => a.id === accountId);
+    const openclawAgentId = account?.openclawAgentId ?? "main";
+
+    // Format messages for the LLM
+    const lines = messages.map((msg, i) => {
+      const from = msg.from_agent;
+      const subject = msg.subject ? ` — ${msg.subject}` : "";
+      const snippet = msg.content.length > 300 ? msg.content.slice(0, 300) + "…" : msg.content;
+      return `${i + 1}. **${from}**${subject}: ${snippet}`;
+    });
+
+    const message = [
+      `📬 ${messages.length} new ClawNet message${messages.length === 1 ? "" : "s"} for ${agentId}:`,
+      "",
+      ...lines,
+      "",
+      "Apply your rules to these messages. Present a brief summary of what arrived.",
+      "End with: Type /inbox to manage your inbox.",
+    ].join("\n");
+
+    const args = [
+      "agent",
+      "--agent", openclawAgentId,
+      "--message", message,
+      "--deliver",
+    ];
+
+    try {
+      await execFileAsync("openclaw", args, { timeout: 120_000 });
+    } catch (err: any) {
+      throw new Error(`openclaw agent --deliver failed: ${err.message?.slice(0, 200)}`);
+    }
+  }
+
   // --- Debounced flush: wait for more messages, then deliver ---
 
   function scheduleFlush(accountId: string, agentId: string) {
@@ -306,7 +305,8 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     }
     const checkData = (await checkRes.json()) as {
       count: number;
-      a2a_dm_count?: number;
+      task_count?: number;
+      sent_task_updates?: number;
       plugin_config?: {
         poll_seconds: number;
         debounce_seconds: number;
@@ -340,12 +340,13 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
       }
     }
 
-    const a2aDmCount = checkData.a2a_dm_count ?? 0;
+    const a2aDmCount = checkData.task_count ?? 0;
+    const sentTaskUpdates = checkData.sent_task_updates ?? 0;
 
     if (checkData.count === 0) {
       // Email inbox clear — release any delivery lock (agent finished processing)
       deliveryLock.delete(account.id);
-      return a2aDmCount;
+      return { a2aDmCount, sentTaskUpdates };
     }
 
     // Skip if a recent webhook delivery is still being processed by the LLM.
@@ -353,7 +354,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     const lockUntil = deliveryLock.get(account.id);
     if (lockUntil && new Date() < lockUntil) {
       api.logger.debug?.(`[clawnet] ${account.id}: ${checkData.count} message(s) waiting (delivery lock active, skipping)`);
-      return a2aDmCount;
+      return { a2aDmCount, sentTaskUpdates };
     }
 
     state.lastInboxNonEmptyAt = new Date();
@@ -366,7 +367,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     }
     const inboxData = (await inboxRes.json()) as { messages: Array<Record<string, any>> };
 
-    if (inboxData.messages.length === 0) return a2aDmCount;
+    if (inboxData.messages.length === 0) return { a2aDmCount, sentTaskUpdates };
 
     // Normalize API field names: API returns "from", plugin uses "from_agent"
     const normalized: InboxMessage[] = inboxData.messages.map((m) => ({
@@ -384,7 +385,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     pendingMessages.set(account.id, [...existing, ...normalized]);
     scheduleFlush(account.id, account.agentId);
 
-    return a2aDmCount;
+    return { a2aDmCount, sentTaskUpdates };
   }
 
   async function pollAccountA2A(account: ClawnetAccount, a2aDmCount: number) {
@@ -468,6 +469,58 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     }
   }
 
+  async function pollSentTaskUpdates(account: ClawnetAccount) {
+    const resolvedToken = resolveToken(account.token);
+    if (!resolvedToken) return;
+
+    // Skip if delivery lock active
+    const lockUntil = deliveryLock.get(account.id);
+    if (lockUntil && new Date() < lockUntil) return;
+
+    // Fetch tasks I sent that need attention
+    const body = {
+      jsonrpc: "2.0",
+      id: `sent-poll-${Date.now()}`,
+      method: "tasks/list",
+      params: { role: "sender", status: "input-required", limit: 50 },
+    };
+    const res = await fetch(`${cfg.baseUrl}/a2a`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${resolvedToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) return;
+
+    const data = (await res.json()) as {
+      result?: { tasks: Array<Record<string, any>> };
+    };
+    const tasks = data.result?.tasks ?? [];
+    if (tasks.length === 0) return;
+
+    api.logger.info(`[clawnet] ${account.id}: ${tasks.length} sent task update(s) to deliver`);
+
+    const messages: InboxMessage[] = tasks.map((task) => {
+      const history = task.history as Array<{ role: string; parts: Array<{ text?: string }> }> ?? [];
+      const lastMsg = history[history.length - 1];
+      const text = lastMsg?.parts?.map((p: any) => p.text).filter(Boolean).join("\n") ?? "";
+      const taskState = task.state ?? "unknown";
+      return {
+        id: task.id,
+        from_agent: task.to, // the agent that responded
+        content: `[Task update: ${taskState}] Re: "${text.slice(0, 100)}${text.length > 100 ? "…" : ""}"`,
+        created_at: (task.status as any)?.timestamp ?? new Date().toISOString(),
+      };
+    });
+
+    state.counters.messagesSeen += messages.length;
+    const existing = pendingMessages.get(account.id) ?? [];
+    pendingMessages.set(account.id, [...existing, ...messages]);
+    scheduleFlush(account.id, account.agentId);
+  }
+
   async function tick() {
     if (stopped) return;
 
@@ -512,7 +565,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     let hadError = false;
     for (const account of enabledAccounts) {
       try {
-        const a2aDmCount = await pollAccount(account);
+        const { a2aDmCount, sentTaskUpdates } = await pollAccount(account);
 
         // Also poll for A2A DMs if any pending
         if (a2aDmCount > 0) {
@@ -522,6 +575,15 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
             api.logger.error(`[clawnet] A2A poll error for ${account.id}: ${a2aErr.message}`);
           }
         }
+
+        // Poll for sent task updates (tasks I sent that got a response)
+        if (sentTaskUpdates > 0) {
+          try {
+            await pollSentTaskUpdates(account);
+          } catch (err: any) {
+            api.logger.error(`[clawnet] Sent task updates error for ${account.id}: ${err.message}`);
+          }
+        }
       } catch (err: any) {
         hadError = true;
         state.lastError = { message: err.message, at: new Date() };

package/src/tools.ts

@@ -173,15 +173,11 @@ const BUILTIN_OPERATIONS: CapabilityOp[] = [
   { operation: "email.allowlist.remove", method: "DELETE", path: "/email/allowlist", description: "Remove sender from email allowlist", params: {
     pattern: { type: "string", description: "Email address or pattern to remove", required: true },
   }},
-  // DMs (legacy — kept for backward compat during transition)
-  { operation: "dm.send", method: "POST", path: "/send", description: "[Legacy] Send a DM to another ClawNet agent. Prefer a2a.send for new messages.", params: {
-    to: { type: "string", description: "Recipient agent name", required: true },
-    message: { type: "string", description: "Message content (max 10000 chars)", required: true },
-  }},
-  { operation: "dm.block", method: "POST", path: "/block", description: "Block an agent from DMing you", params: {
+  // Agent moderation
+  { operation: "agent.block", method: "POST", path: "/block", description: "Block an agent from contacting you", params: {
     agent_id: { type: "string", description: "Agent to block", required: true },
   }},
-  { operation: "dm.unblock", method: "POST", path: "/unblock", description: "Unblock an agent", params: {
+  { operation: "agent.unblock", method: "POST", path: "/unblock", description: "Unblock an agent", params: {
     agent_id: { type: "string", description: "Agent to unblock", required: true },
   }},
   // Messages (cross-cutting)
@@ -222,8 +218,10 @@ const BUILTIN_OPERATIONS: CapabilityOp[] = [
     title: { type: "string", description: "Event title", required: true },
     starts_at: { type: "string", description: "ISO 8601 start time", required: true },
     ends_at: { type: "string", description: "ISO 8601 end time" },
+    all_day: { type: "boolean", description: "Mark as all-day event (spans full calendar day)" },
     location: { type: "string", description: "Event location" },
     description: { type: "string", description: "Event description" },
+    remind_minutes: { type: "number", description: "Minutes before event to send notification (0-10080, default 15, null to disable)" },
     attendees: { type: "array", description: "Array of {email, name?} — each gets a .ics invite" },
   }},
   { operation: "calendar.list", method: "GET", path: "/calendar/events", description: "List calendar events", params: {
@@ -235,7 +233,11 @@ const BUILTIN_OPERATIONS: CapabilityOp[] = [
     event_id: { type: "string", description: "Event ID", required: true },
     title: { type: "string", description: "New title" },
     starts_at: { type: "string", description: "New start time" },
+    ends_at: { type: "string", description: "New end time" },
+    all_day: { type: "boolean", description: "Mark as all-day event" },
     location: { type: "string", description: "New location" },
+    description: { type: "string", description: "New description" },
+    remind_minutes: { type: "number", description: "Minutes before event to send notification (0-10080, null to disable)" },
   }},
   { operation: "calendar.delete", method: "DELETE", path: "/calendar/events/:event_id", description: "Delete event (sends cancellation to attendees)", params: {
     event_id: { type: "string", description: "Event ID", required: true },
@@ -335,7 +337,7 @@ export function registerTools(api: any) {
 
   api.registerTool((ctx: { agentId?: string; sessionKey?: string }) => ({
     name: "clawnet_inbox_check",
-    description: toolDesc("clawnet_inbox_check", "Check if you have new messages. Returns total count and breakdown by type (email, DMs). Lightweight — use this before fetching full inbox. Use clawnet_email_inbox for emails, or clawnet_call with dm.inbox for DMs."),
+    description: toolDesc("clawnet_inbox_check", "Check if you have new messages. Returns total count and breakdown by type (email, tasks). Lightweight — use this before fetching full inbox. Use clawnet_email_inbox for emails, or clawnet_task_inbox for agent tasks."),
     parameters: {
       type: "object",
       properties: {},
@@ -436,7 +438,7 @@ export function registerTools(api: any) {
 
   api.registerTool((ctx: { agentId?: string; sessionKey?: string }) => ({
     name: "clawnet_inbox_session",
-    description: toolDesc("clawnet_inbox_session", "Start an interactive email inbox session. Returns your emails with assigned numbers and a triage protocol for presenting them to your human. Use this when your human asks to manage, check, or go through their email."),
+    description: toolDesc("clawnet_inbox_session", "Start an interactive inbox session. Returns your emails with assigned numbers and a triage protocol. IMPORTANT: After calling this tool, also call clawnet_task_inbox to get pending agent tasks — present both emails and tasks together to your human."),
     parameters: {
       type: "object",
       properties: {
@@ -493,10 +495,40 @@ export function registerTools(api: any) {
         };
       });
 
+      // Fetch A2A tasks via REST-style POST to /a2a
+      let tasks: Array<Record<string, unknown>> = [];
+      try {
+        const taskResult = await apiCall(cfg, "POST", "/a2a", {
+          jsonrpc: "2.0",
+          id: `inbox-${Date.now()}`,
+          method: "tasks/list",
+          params: { status: "submitted,working" },
+        }, ctx?.agentId, ctx?.sessionKey);
+        const taskData = taskResult.data as any;
+        const rawTasks = taskData?.result?.tasks ?? taskData?.tasks ?? [];
+        tasks = rawTasks.map((t: any, i: number) => {
+          const lastMsg = (t.history ?? []).slice(-1)[0];
+          const text = lastMsg?.parts?.map((p: any) => p.text).filter(Boolean).join("\n") ?? "";
+          return {
+            n: emails.length + i + 1,
+            id: t.id,
+            type: "a2a_task",
+            from: t.from,
+            trust_tier: t.trustTier ?? "public",
+            content: text.slice(0, 200),
+            state: t.status?.state ?? "unknown",
+            received_at: t.status?.timestamp,
+          };
+        });
+      } catch {
+        // Non-fatal — show emails even if task fetch fails
+      }
+
       return textResult({
         protocol,
         emails,
-        counts: { total: emails.length, new: newCount, read: readCount },
+        tasks,
+        counts: { total: emails.length + tasks.length, emails: emails.length, tasks: tasks.length, new: newCount, read: readCount },
       });
     },
   }));
@@ -553,14 +585,19 @@ export function registerTools(api: any) {
     parameters: {
       type: "object",
       properties: {
-        status: { type: "string", description: "Filter: 'submitted' (default), 'working', 'completed', 'failed', or 'all'" },
+        status: { type: "string", description: "Filter: 'pending' (default — shows submitted + working), 'submitted', 'working', 'completed', 'failed', or 'all'" },
         limit: { type: "number", description: "Max tasks (default 50, max 100)" },
       },
     },
     async execute(_id: string, params: { status?: string; limit?: number }) {
       const cfg = loadFreshConfig(api);
-      const a2aParams: Record<string, unknown> = {};
-      if (params.status) a2aParams.status = params.status;
+      const a2aParams: Record<string, unknown> = { role: "recipient" };
+      const statusFilter = params.status || "pending";
+      if (statusFilter === "pending") {
+        a2aParams.status = "submitted,working";
+      } else {
+        a2aParams.status = statusFilter;
+      }
       if (params.limit) a2aParams.limit = params.limit;
       const result = await a2aCall(cfg, "/a2a", "tasks/list", a2aParams, ctx?.agentId, ctx?.sessionKey);
       return textResult(result.data);
@@ -637,7 +674,7 @@ export function registerTools(api: any) {
     parameters: {
       type: "object",
       properties: {
-        operation: { type: "string", description: "Operation name from clawnet_capabilities (e.g. 'dm.send', 'profile.update', 'calendar.create')" },
+        operation: { type: "string", description: "Operation name from clawnet_capabilities (e.g. 'agent.block', 'profile.update', 'calendar.create')" },
         params: { type: "object", description: "Operation parameters (see clawnet_capabilities for schema)" },
       },
       required: ["operation"],