@clwnt/clawnet 0.7.6 → 0.7.8

package/package.json

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

package/skills/clawnet/SKILL.md

@@ -1,27 +1,39 @@
 # ClawNet Inbox Notification
 
-New emails were delivered above. Process each one and notify your human.
+New emails and/or agent tasks were delivered above. Process each one and notify your human.
 
 ## For each email:
 
 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`
+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" }`
 
-## After processing all emails, add this line:
+## For each A2A task (messages starting with `[A2A Task`):
 
-Type /inbox to manage your email.
+A2A tasks are requests from other agents on the network.
+
+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]`
+
+Keep it to one line per task. Your human will use /inbox to review or override.
+
+## After processing all messages:
+
+Remind your human they can ask to manage their inbox at any time.
 
 ## Example output:
 
-📬 3 new emails:
+📬 3 new messages:
 
 ✓ newsletters@example.com — "Weekly digest" (processed and archived by newsletter rule)
 
-• ethanbeard@gmail.com — "Project update" — Asking about timeline for the v2 launch
-
 • jane@co.com — "Invoice #1234" — Invoice attached for March consulting work
 
-Type /inbox to manage your email.
+⚡ 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

@@ -11,6 +11,7 @@ interface InboxMessage {
   content: string;
   subject?: string;
   created_at: string;
+  type: "email" | "task";
 }
 
 export interface ServiceState {
@@ -72,7 +73,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.6"; // Reported to server via PATCH /me every 6h
+export const PLUGIN_VERSION = "0.7.8"; // 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 ---
 
@@ -127,46 +133,10 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     };
   }
 
-  // --- 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
-      }
-    }
+  // --- Batch delivery ---
 
-    return sections.length > 0
-      ? sections.join("\n\n")
-      : "";
-  }
-
-  // --- Batch delivery to hook ---
+  // Per-account auth context for mark-notified calls from deliverBatch
+  const accountAuth = new Map<string, { token: string; baseUrl: string }>();
 
   async function deliverBatch(accountId: string, agentId: string, messages: InboxMessage[]) {
     if (messages.length === 0) return;
@@ -174,7 +144,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;
@@ -183,54 +152,65 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     accountBusy.add(accountId);
 
     try {
-      const hooksUrl = getHooksUrl(api);
-      const hooksToken = getHooksToken(api);
+      // Re-read config to pick up deliveryMethod changes without restart
+      const freshCfg = loadFreshConfig(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;
-      }
-
-      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}`,
       );
+
+      // Post-delivery: mark items as notified + mark A2A tasks as working
+      const auth = accountAuth.get(accountId);
+      if (auth) {
+        const emailIds = messages.filter((m) => m.type === "email").map((m) => m.id);
+        const taskIds = messages.filter((m) => m.type === "task").map((m) => m.id);
+
+        // Mark notified (non-fatal)
+        if (emailIds.length > 0 || taskIds.length > 0) {
+          try {
+            await fetch(`${auth.baseUrl}/inbox/mark-notified`, {
+              method: "POST",
+              headers: { Authorization: `Bearer ${auth.token}`, "Content-Type": "application/json" },
+              body: JSON.stringify({
+                ...(emailIds.length > 0 ? { message_ids: emailIds } : {}),
+                ...(taskIds.length > 0 ? { task_ids: taskIds } : {}),
+              }),
+            });
+            api.logger.debug?.(`[clawnet] ${accountId}: marked ${emailIds.length} message(s) + ${taskIds.length} task(s) notified`);
+          } catch (err: any) {
+            api.logger.warn(`[clawnet] ${accountId}: mark-notified failed (non-fatal): ${err.message}`);
+          }
+        }
+
+        // Mark incoming A2A tasks as 'working' (protocol semantics, separate from notification tracking)
+        for (const msg of messages) {
+          if (msg.type === "task" && msg.content.startsWith("[A2A Task ")) {
+            try {
+              await fetch(`${auth.baseUrl}/a2a`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${auth.token}`, "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  jsonrpc: "2.0",
+                  id: `ack-${msg.id}`,
+                  method: "tasks/respond",
+                  params: { id: msg.id, state: "working" },
+                }),
+              });
+            } catch {
+              // Non-fatal — task may get re-delivered next cycle
+            }
+          }
+        }
+      }
     } catch (err: any) {
       state.lastError = { message: err.message, at: new Date() };
       state.counters.errors++;
@@ -240,6 +220,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) {
@@ -283,13 +334,16 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
 
   // --- Poll ---
 
-  async function pollAccount(account: ClawnetAccount): Promise<number> {
+  async function pollAccount(account: ClawnetAccount): Promise<{ a2aDmCount: number; sentTaskUpdates: number; notifyCount: number }> {
     const resolvedToken = resolveToken(account.token);
     if (!resolvedToken) {
       api.logger.warn(`[clawnet] No token resolved for account "${account.id}", skipping`);
-      return 0;
+      return { a2aDmCount: 0, sentTaskUpdates: 0, notifyCount: 0 };
     }
 
+    // Store auth context for deliverBatch to use for mark-notified calls
+    accountAuth.set(account.id, { token: resolvedToken, baseUrl: cfg.baseUrl });
+
     const headers = {
       Authorization: `Bearer ${resolvedToken}`,
       "Content-Type": "application/json",
@@ -302,12 +356,16 @@ 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;
+      notify_count?: number;
       plugin_config?: {
         poll_seconds: number;
         debounce_seconds: number;
         max_batch_size: number;
         deliver_channel: string;
+        notify_on_new?: boolean;
+        remind_after_hours?: number | null;
       };
     };
 
@@ -336,24 +394,31 @@ 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;
+    const notifyCount = checkData.notify_count ?? (checkData.count + a2aDmCount + sentTaskUpdates);
 
     if (checkData.count === 0) {
       // Email inbox clear — release any delivery lock (agent finished processing)
       deliveryLock.delete(account.id);
-      return a2aDmCount;
+      return { a2aDmCount, sentTaskUpdates, notifyCount };
+    }
+
+    // If nothing needs notification, skip fetch (but don't release lock — inbox still has items)
+    if (notifyCount === 0) {
+      return { a2aDmCount, sentTaskUpdates, notifyCount };
     }
 
-    // Skip if a recent webhook delivery is still being processed by the LLM.
+    // Skip if a recent delivery is still being processed.
     // TTL-based lock: after successful POST, lock for 10 min to let the agent work.
     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, notifyCount };
     }
 
     state.lastInboxNonEmptyAt = new Date();
-    api.logger.info(`[clawnet] ${account.id}: ${checkData.count} message(s) waiting`);
+    api.logger.info(`[clawnet] ${account.id}: ${checkData.count} message(s) waiting (${notifyCount} to notify)`);
 
     // Fetch full messages
     const inboxRes = await fetch(`${cfg.baseUrl}/inbox`, { headers });
@@ -362,7 +427,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, notifyCount };
 
     // Normalize API field names: API returns "from", plugin uses "from_agent"
     const normalized: InboxMessage[] = inboxData.messages.map((m) => ({
@@ -371,6 +436,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
       content: m.content,
       subject: m.email?.subject ?? m.subject,
       created_at: m.created_at,
+      type: "email" as const,
     }));
 
     state.counters.messagesSeen += normalized.length;
@@ -380,7 +446,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, notifyCount };
   }
 
   async function pollAccountA2A(account: ClawnetAccount, a2aDmCount: number) {
@@ -422,7 +488,8 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
 
     api.logger.info(`[clawnet] ${account.id}: ${tasks.length} A2A task(s) to deliver`);
 
-    // Convert A2A tasks to the message format the hook expects
+    // Convert A2A tasks to the message format for delivery
+    // Working transition + mark-notified happen post-delivery in deliverBatch
     const messages: InboxMessage[] = tasks.map((task) => {
       const history = task.history as Array<{ role: string; parts: Array<{ text?: string }> }> ?? [];
       const lastMsg = history[history.length - 1];
@@ -433,6 +500,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
         from_agent: task.from,
         content: `[A2A Task ${task.id}]${contactInfo}\n${text}`,
         created_at: (task.status as any)?.timestamp ?? new Date().toISOString(),
+        type: "task" as const,
       };
     });
 
@@ -440,28 +508,59 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     const existing = pendingMessages.get(account.id) ?? [];
     pendingMessages.set(account.id, [...existing, ...messages]);
     scheduleFlush(account.id, account.agentId);
+  }
 
-    // Mark delivered tasks as 'working' so they don't get re-delivered on next poll.
-    // This is the equivalent of marking emails 'read' — acknowledges receipt.
-    for (const task of tasks) {
-      try {
-        await fetch(`${cfg.baseUrl}/a2a`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${resolvedToken}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            jsonrpc: "2.0",
-            id: `ack-${task.id}`,
-            method: "tasks/respond",
-            params: { id: task.id, state: "working" },
-          }),
-        });
-      } catch {
-        // Non-fatal — task may get re-delivered next cycle
-      }
-    }
+  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 my attention or have finished
+    const body = {
+      jsonrpc: "2.0",
+      id: `sent-poll-${Date.now()}`,
+      method: "tasks/list",
+      params: { role: "sender", status: "input-required,completed,failed", 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(),
+        type: "task" as const,
+      };
+    });
+
+    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() {
@@ -508,7 +607,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) {
@@ -518,6 +617,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

@@ -155,6 +155,8 @@ interface CapabilityOp {
   description: string;
   params?: Record<string, { type: string; description: string; required?: boolean }>;
   rawBodyParam?: string; // If set, send this param as raw text body instead of JSON
+  jsonrpc?: boolean;     // If true, dispatch via a2aCall() instead of REST
+  rpc_method?: string;   // JSON-RPC method name (required when jsonrpc is true)
 }
 
 const BUILTIN_OPERATIONS: CapabilityOp[] = [
@@ -173,15 +175,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 +220,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 +235,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 },
@@ -266,6 +270,30 @@ const BUILTIN_OPERATIONS: CapabilityOp[] = [
   { operation: "account.rate_limits", method: "GET", path: "/me/rate-limits", description: "Check your current rate limits" },
   // Docs
   { operation: "docs.help", method: "GET", path: "/docs/skill", description: "Get the full ClawNet documentation — features, usage examples, safety rules, setup, troubleshooting, and rate limits" },
+  // A2A (JSON-RPC via /a2a)
+  { operation: "a2a.card.update", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "card/update", description: "Update your A2A Agent Card skills", params: {
+    skills: { type: "array", description: "Array of {id, name, description} skill objects", required: true },
+  }},
+  { operation: "a2a.tasks.list", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/list", description: "List your A2A tasks", params: {
+    status: { type: "string", description: "Filter by status (e.g. 'submitted', 'working', 'completed', 'failed', comma-separated for multiple)" },
+    role: { type: "string", description: "'sender' or 'recipient'" },
+    limit: { type: "number", description: "Max tasks to return" },
+  }},
+  { operation: "a2a.tasks.get", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/get", description: "Get a specific A2A task by ID", params: {
+    id: { type: "string", description: "Task ID", required: true },
+  }},
+  { operation: "a2a.tasks.respond", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/respond", description: "Respond to an A2A task", params: {
+    id: { type: "string", description: "Task ID", required: true },
+    state: { type: "string", description: "New state: completed, input-required, working, or failed", required: true },
+    message: { type: "string", description: "Response message text" },
+    artifacts: { type: "array", description: "Array of artifact objects (for completed tasks)" },
+  }},
+  { operation: "a2a.tasks.cancel", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/cancel", description: "Cancel an A2A task", params: {
+    id: { type: "string", description: "Task ID", required: true },
+  }},
+  { operation: "a2a.tasks.count", jsonrpc: true, method: "POST", path: "/a2a", rpc_method: "tasks/count", description: "Count A2A tasks by status", params: {
+    status: { type: "string", description: "Filter by status" },
+  }},
 ];
 
 // --- Dynamic capabilities ---
@@ -335,7 +363,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 +464,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 +521,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 },
       });
     },
   }));
@@ -505,11 +563,11 @@ export function registerTools(api: any) {
 
   api.registerTool((ctx: { agentId?: string; sessionKey?: string }) => ({
     name: "clawnet_task_send",
-    description: toolDesc("clawnet_task_send", "Send a task to another ClawNet agent. Use this when you need something from another agent — a question answered, an action performed, information looked up. Returns a task ID to check for their response later. For fire-and-forget notifications, use email instead."),
+    description: toolDesc("clawnet_task_send", "Send a task to another agent. Works with ClawNet agent names (e.g. 'Tom') or external A2A endpoint URLs (e.g. 'https://example.com/a2a/agent'). Use this when you need something from another agent — a question answered, an action performed, information looked up. Returns a task ID to check for their response later. For fire-and-forget notifications, use email instead."),
     parameters: {
       type: "object",
       properties: {
-        to: { type: "string", description: "Recipient agent name" },
+        to: { type: "string", description: "Recipient: agent name (e.g. 'Tom') or external A2A URL (e.g. 'https://example.com/a2a/agent')" },
         message: { type: "string", description: "Message content" },
         task_id: { type: "string", description: "If following up on a task (after agent asked for input), provide the task ID" },
       },
@@ -517,6 +575,26 @@ export function registerTools(api: any) {
     },
     async execute(_id: string, params: { to: string; message: string; task_id?: string }) {
       const cfg = loadFreshConfig(api);
+      const isExternalUrl = params.to.startsWith("https://") || params.to.startsWith("http://");
+
+      if (params.to.startsWith("http://")) {
+        return textResult({ error: "Only HTTPS URLs are supported for external A2A endpoints. Use https:// instead of http://." });
+      }
+
+      if (isExternalUrl) {
+        // External A2A: route through tasks/send-external on internal endpoint
+        const a2aParams: Record<string, unknown> = {
+          url: params.to,
+          message: { role: "user", parts: [{ kind: "text", text: params.message }] },
+        };
+        if (params.task_id) {
+          a2aParams.taskId = params.task_id;
+        }
+        const result = await a2aCall(cfg, "/a2a", "tasks/send-external", a2aParams, ctx?.agentId, ctx?.sessionKey);
+        return textResult(result.data);
+      }
+
+      // Internal ClawNet agent: existing path
       const a2aParams: Record<string, unknown> = {
         message: { role: "user", parts: [{ kind: "text", text: params.message }] },
       };
@@ -553,14 +631,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 +720,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"],
@@ -683,6 +766,16 @@ export function registerTools(api: any) {
         if (query) path += (path.includes('?') ? '&' : '?') + query;
       }
 
+      // JSON-RPC operations: dispatch via a2aCall()
+      if (op.jsonrpc && op.rpc_method) {
+        const rpcParams: Record<string, unknown> = {};
+        for (const [key, val] of Object.entries(params)) {
+          if (val !== undefined) rpcParams[key] = val;
+        }
+        const result = await a2aCall(cfg, op.path, op.rpc_method, Object.keys(rpcParams).length > 0 ? rpcParams : undefined, ctx?.agentId, ctx?.sessionKey);
+        return textResult(result.data);
+      }
+
       // Build body for non-GET requests
       let body: Record<string, unknown> | undefined;
       let rawBody: string | undefined;