aamp-openclaw-plugin 0.1.27 → 0.1.29

package/dist/index.js

@@ -7,9 +7,10 @@ var AAMP_HEADER = {
   VERSION: "X-AAMP-Version",
   INTENT: "X-AAMP-Intent",
   TASK_ID: "X-AAMP-TaskId",
-  TIMEOUT: "X-AAMP-Timeout",
   CONTEXT_LINKS: "X-AAMP-ContextLinks",
   DISPATCH_CONTEXT: "X-AAMP-Dispatch-Context",
+  PRIORITY: "X-AAMP-Priority",
+  EXPIRES_AT: "X-AAMP-Expires-At",
   STATUS: "X-AAMP-Status",
   OUTPUT: "X-AAMP-Output",
   ERROR_MSG: "X-AAMP-ErrorMsg",
@@ -17,10 +18,59 @@ var AAMP_HEADER = {
   QUESTION: "X-AAMP-Question",
   BLOCKED_REASON: "X-AAMP-BlockedReason",
   SUGGESTED_OPTIONS: "X-AAMP-SuggestedOptions",
-  PARENT_TASK_ID: "X-AAMP-ParentTaskId"
+  PARENT_TASK_ID: "X-AAMP-ParentTaskId",
+  CARD_SUMMARY: "X-AAMP-Card-Summary"
 };
 
 // ../sdk/src/parser.ts
+function normalizeBodyText(value) {
+  return value?.replace(/\r\n/g, "\n").trim() ?? "";
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractBodySection(bodyText, label, nextLabels) {
+  if (!bodyText)
+    return "";
+  const nextPattern = nextLabels.length ? `(?=\\n(?:${nextLabels.map(escapeRegex).join("|")}):|$)` : "$";
+  const pattern = new RegExp(
+    `(?:^|\\n)${escapeRegex(label)}:\\s*([\\s\\S]*?)${nextPattern}`,
+    "i"
+  );
+  const match = pattern.exec(bodyText);
+  return match?.[1]?.trim() ?? "";
+}
+function parseSuggestedOptionsBlock(block) {
+  if (!block.trim())
+    return [];
+  return block.split("\n").map((line) => line.replace(/^\s*(?:[-*]|\d+\.)\s*/, "").trim()).filter(Boolean);
+}
+function parseTaskResultBody(bodyText) {
+  const normalized = normalizeBodyText(bodyText);
+  if (!normalized)
+    return { output: "" };
+  const output = extractBodySection(normalized, "Output", ["Error"]);
+  const errorMsg = extractBodySection(normalized, "Error", []);
+  if (output || errorMsg) {
+    return { output, ...errorMsg ? { errorMsg } : {} };
+  }
+  return { output: normalized };
+}
+function parseTaskHelpBody(bodyText) {
+  const normalized = normalizeBodyText(bodyText);
+  if (!normalized) {
+    return { question: "", blockedReason: "", suggestedOptions: [] };
+  }
+  const question = extractBodySection(normalized, "Question", ["Blocked reason", "Suggested options"]);
+  const blockedReason = extractBodySection(normalized, "Blocked reason", ["Suggested options"]);
+  const suggestedOptions = parseSuggestedOptionsBlock(
+    extractBodySection(normalized, "Suggested options", [])
+  );
+  if (question || blockedReason || suggestedOptions.length) {
+    return { question, blockedReason, suggestedOptions };
+  }
+  return { question: normalized, blockedReason: "", suggestedOptions: [] };
+}
 function decodeMimeEncodedWordSegment(segment) {
   const match = /^=\?([^?]+)\?([bBqQ])\?([^?]*)\?=$/.exec(segment);
   if (!match)
@@ -131,18 +181,20 @@ function parseAampHeaders(meta) {
   const to = meta.to.replace(/^<|>$/g, "");
   const decodedSubject = decodeMimeEncodedWords(meta.subject);
   if (intent === "task.dispatch") {
-    const timeoutStr = getAampHeader(headers, AAMP_HEADER.TIMEOUT) ?? "300";
     const contextLinksStr = getAampHeader(headers, AAMP_HEADER.CONTEXT_LINKS) ?? "";
     const dispatchContext = parseDispatchContextHeader(
       getAampHeader(headers, AAMP_HEADER.DISPATCH_CONTEXT)
     );
     const parentTaskId = getAampHeader(headers, AAMP_HEADER.PARENT_TASK_ID);
+    const priority = getAampHeader(headers, AAMP_HEADER.PRIORITY) ?? "normal";
+    const expiresAt = getAampHeader(headers, AAMP_HEADER.EXPIRES_AT);
     const dispatch = {
       protocolVersion,
       intent: "task.dispatch",
       taskId,
       title: decodedSubject.replace(/^\[AAMP Task\]\s*/, "").trim() || "Untitled Task",
-      timeoutSecs: parseInt(timeoutStr, 10) || 300,
+      priority: priority === "urgent" || priority === "high" ? priority : "normal",
+      ...expiresAt ? { expiresAt } : {},
       contextLinks: contextLinksStr ? contextLinksStr.split(",").map((s) => s.trim()).filter(Boolean) : [],
       ...dispatchContext ? { dispatchContext } : {},
       ...parentTaskId ? { parentTaskId } : {},
@@ -155,10 +207,24 @@ function parseAampHeaders(meta) {
     };
     return dispatch;
   }
+  if (intent === "task.cancel") {
+    const cancel = {
+      protocolVersion,
+      intent: "task.cancel",
+      taskId,
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+    };
+    return cancel;
+  }
   if (intent === "task.result") {
+    const parsedBody = parseTaskResultBody(meta.bodyText);
     const status = getAampHeader(headers, AAMP_HEADER.STATUS) ?? "completed";
-    const output = getAampHeader(headers, AAMP_HEADER.OUTPUT) ?? "";
-    const errorMsg = getAampHeader(headers, AAMP_HEADER.ERROR_MSG);
+    const output = getAampHeader(headers, AAMP_HEADER.OUTPUT) ?? parsedBody.output;
+    const errorMsg = getAampHeader(headers, AAMP_HEADER.ERROR_MSG) ?? parsedBody.errorMsg;
     const structuredResult = decodeStructuredResult(
       getAampHeader(headers, AAMP_HEADER.STRUCTURED_RESULT)
     );
@@ -176,9 +242,10 @@ function parseAampHeaders(meta) {
     };
     return result;
   }
-  if (intent === "task.help_needed" || intent === "task.help") {
-    const question = getAampHeader(headers, AAMP_HEADER.QUESTION) ?? "";
-    const blockedReason = getAampHeader(headers, AAMP_HEADER.BLOCKED_REASON) ?? "";
+  if (intent === "task.help_needed") {
+    const parsedBody = parseTaskHelpBody(meta.bodyText);
+    const question = getAampHeader(headers, AAMP_HEADER.QUESTION) ?? parsedBody.question;
+    const blockedReason = getAampHeader(headers, AAMP_HEADER.BLOCKED_REASON) ?? parsedBody.blockedReason;
     const suggestedOptionsStr = getAampHeader(headers, AAMP_HEADER.SUGGESTED_OPTIONS) ?? "";
     const help = {
       protocolVersion,
@@ -186,7 +253,7 @@ function parseAampHeaders(meta) {
       taskId,
       question: decodeMimeEncodedWords(question),
       blockedReason: decodeMimeEncodedWords(blockedReason),
-      suggestedOptions: suggestedOptionsStr ? suggestedOptionsStr.split("|").map((s) => decodeMimeEncodedWords(s.trim())).filter(Boolean) : [],
+      suggestedOptions: suggestedOptionsStr ? suggestedOptionsStr.split("|").map((s) => decodeMimeEncodedWords(s.trim())).filter(Boolean) : parsedBody.suggestedOptions,
       from,
       to,
       messageId: meta.messageId
@@ -204,16 +271,45 @@ function parseAampHeaders(meta) {
     };
     return ack;
   }
+  if (intent === "card.query") {
+    const cardQuery = {
+      protocolVersion,
+      intent: "card.query",
+      taskId,
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+    };
+    return cardQuery;
+  }
+  if (intent === "card.response") {
+    const summary = getAampHeader(headers, AAMP_HEADER.CARD_SUMMARY) ?? "";
+    const cardResponse = {
+      protocolVersion,
+      intent: "card.response",
+      taskId,
+      summary: decodeMimeEncodedWords(summary) || decodedSubject.replace(/^\[AAMP Card\]\s*/i, "").trim(),
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+    };
+    return cardResponse;
+  }
   return null;
 }
 function buildDispatchHeaders(params) {
   const headers = {
     [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
     [AAMP_HEADER.INTENT]: "task.dispatch",
-    [AAMP_HEADER.TASK_ID]: params.taskId
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.PRIORITY]: params.priority ?? "normal"
   };
-  if (params.timeoutSecs != null) {
-    headers[AAMP_HEADER.TIMEOUT] = String(params.timeoutSecs);
+  if (params.expiresAt) {
+    headers[AAMP_HEADER.EXPIRES_AT] = params.expiresAt;
   }
   if (params.contextLinks.length > 0) {
     headers[AAMP_HEADER.CONTEXT_LINKS] = params.contextLinks.join(",");
@@ -227,6 +323,13 @@ function buildDispatchHeaders(params) {
   }
   return headers;
 }
+function buildCancelHeaders(params) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.cancel",
+    [AAMP_HEADER.TASK_ID]: params.taskId
+  };
+}
 function buildAckHeaders(opts) {
   return {
     [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
@@ -239,12 +342,8 @@ function buildResultHeaders(params) {
     [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
     [AAMP_HEADER.INTENT]: "task.result",
     [AAMP_HEADER.TASK_ID]: params.taskId,
-    [AAMP_HEADER.STATUS]: params.status,
-    [AAMP_HEADER.OUTPUT]: params.output
+    [AAMP_HEADER.STATUS]: params.status
   };
-  if (params.errorMsg) {
-    headers[AAMP_HEADER.ERROR_MSG] = params.errorMsg;
-  }
   const structuredResult = encodeStructuredResult(params.structuredResult);
   if (structuredResult) {
     headers[AAMP_HEADER.STRUCTURED_RESULT] = structuredResult;
@@ -256,11 +355,24 @@ function buildHelpHeaders(params) {
     [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
     [AAMP_HEADER.INTENT]: "task.help_needed",
     [AAMP_HEADER.TASK_ID]: params.taskId,
-    [AAMP_HEADER.QUESTION]: params.question,
-    [AAMP_HEADER.BLOCKED_REASON]: params.blockedReason,
     [AAMP_HEADER.SUGGESTED_OPTIONS]: params.suggestedOptions.join("|")
   };
 }
+function buildCardQueryHeaders(params) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "card.query",
+    [AAMP_HEADER.TASK_ID]: params.taskId
+  };
+}
+function buildCardResponseHeaders(params) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "card.response",
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.CARD_SUMMARY]: params.summary
+  };
+}
 
 // ../sdk/src/tiny-emitter.ts
 var TinyEmitter = class {
@@ -504,7 +616,7 @@ var JmapPushClient = class extends TinyEmitter {
    * Process a received email.
    *
    * Priority:
-   * 1. If X-AAMP-Intent is present → emit typed AAMP event (task.dispatch / task.result / task.help_needed)
+     * 1. If X-AAMP-Intent is present → emit typed AAMP event (task.dispatch / task.cancel / task.result / task.help_needed)
    * 2. If In-Reply-To is present → emit 'reply' event so the application layer can
    *    resolve the thread (inReplyTo → taskId via Redis/DB) and handle human replies.
    * 3. Otherwise → ignore (not an AAMP-related email)
@@ -520,16 +632,18 @@ var JmapPushClient = class extends TinyEmitter {
     if (this.seenMessageIds.has(messageId))
       return;
     this.seenMessageIds.add(messageId);
+    const aampTextPartId = email.textBody?.[0]?.partId;
+    const aampBodyText = aampTextPartId ? (email.bodyValues?.[aampTextPartId]?.value ?? "").trim() : "";
     const msg = parseAampHeaders({
       from: fromAddr,
       to: toAddr,
       messageId,
       subject: email.subject ?? "",
-      headers: headerMap
+      headers: headerMap,
+      bodyText: aampBodyText
     });
     if (msg && "intent" in msg) {
-      const aampTextPartId = email.textBody?.[0]?.partId;
-      const aampBodyText = aampTextPartId ? (email.bodyValues?.[aampTextPartId]?.value ?? "").trim() : "";
+      ;
       msg.bodyText = aampBodyText;
       const receivedAttachments = (email.attachments ?? []).map((a) => ({
         filename: a.name ?? "attachment",
@@ -549,16 +663,24 @@ var JmapPushClient = class extends TinyEmitter {
         case "task.dispatch":
           this.emit("task.dispatch", aampMsg);
           break;
+        case "task.cancel":
+          this.emit("task.cancel", aampMsg);
+          break;
         case "task.result":
           this.emit("task.result", aampMsg);
           break;
         case "task.help_needed":
           this.emit("task.help_needed", aampMsg);
-          this.emit("task.help", aampMsg);
           break;
         case "task.ack":
           this.emit("task.ack", aampMsg);
           break;
+        case "card.query":
+          this.emit("card.query", aampMsg);
+          break;
+        case "card.response":
+          this.emit("card.response", aampMsg);
+          break;
       }
       return;
     }
@@ -886,7 +1008,7 @@ var JmapPushClient = class extends TinyEmitter {
    * Useful as a safety net when the WebSocket stays "connected"
    * but a notification is missed by an intermediate layer.
    */
-  async reconcileRecentEmails(limit = 20) {
+  async reconcileRecentEmails(limit = 20, opts) {
     if (!this.session) {
       this.session = await this.fetchSession();
     }
@@ -933,7 +1055,7 @@ var JmapPushClient = class extends TinyEmitter {
       const bTs = new Date(b.receivedAt).getTime();
       return aTs - bTs;
     })) {
-      if (!this.shouldProcessBootstrapEmail(email))
+      if (!opts?.includeHistorical && !this.shouldProcessBootstrapEmail(email))
         continue;
       this.processEmail(email);
     }
@@ -945,7 +1067,16 @@ var JmapPushClient = class extends TinyEmitter {
 import { createTransport } from "nodemailer";
 import { randomUUID } from "crypto";
 var sanitize = (s) => s.replace(/[\r\n]/g, " ").trim();
-var SmtpSender = class {
+function deriveMailboxServiceDefaults(email, baseUrl2) {
+  const domain = email.split("@")[1]?.trim();
+  const resolvedBaseUrl = baseUrl2?.trim() || (domain ? `https://${domain}` : void 0);
+  const smtpHost = domain || (resolvedBaseUrl ? new URL(resolvedBaseUrl).hostname : "localhost");
+  return {
+    smtpHost,
+    httpBaseUrl: resolvedBaseUrl
+  };
+}
+var SmtpSender = class _SmtpSender {
   constructor(config) {
     this.config = config;
     this.transport = createTransport({
@@ -962,6 +1093,20 @@ var SmtpSender = class {
     });
   }
   transport;
+  discoveredApiUrlPromise = null;
+  static fromMailboxIdentity(config) {
+    const derived = deriveMailboxServiceDefaults(config.email, config.baseUrl);
+    return new _SmtpSender({
+      host: derived.smtpHost,
+      port: config.smtpPort ?? 587,
+      user: config.email,
+      password: config.password,
+      httpBaseUrl: derived.httpBaseUrl,
+      authToken: Buffer.from(`${config.email}:${config.password}`).toString("base64"),
+      secure: config.secure,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+  }
   senderDomain() {
     return this.config.user.split("@")[1]?.toLowerCase() ?? "";
   }
@@ -973,12 +1118,38 @@ var SmtpSender = class {
       this.config.httpBaseUrl && this.config.authToken && this.senderDomain() && this.senderDomain() === this.recipientDomain(to)
     );
   }
-  async sendViaHttp(opts) {
+  async resolveAampApiUrl() {
     const base = this.config.httpBaseUrl?.replace(/\/$/, "");
-    if (!base || !this.config.authToken) {
+    if (!base) {
+      throw new Error("HTTP send fallback is not configured");
+    }
+    if (!this.discoveredApiUrlPromise) {
+      this.discoveredApiUrlPromise = (async () => {
+        const discoveryRes = await fetch(`${base}/.well-known/aamp`);
+        if (!discoveryRes.ok) {
+          throw new Error(`AAMP discovery failed: ${discoveryRes.status}`);
+        }
+        const discovery = await discoveryRes.json();
+        if (!discovery.api?.url) {
+          throw new Error("AAMP discovery did not return api.url");
+        }
+        return new URL(discovery.api.url, `${base}/`).toString();
+      })();
+    }
+    try {
+      return await this.discoveredApiUrlPromise;
+    } catch (err) {
+      this.discoveredApiUrlPromise = null;
+      throw err;
+    }
+  }
+  async sendViaHttp(opts) {
+    if (!this.config.authToken) {
       throw new Error("HTTP send fallback is not configured");
     }
-    const res = await fetch(`${base}/api/send`, {
+    const apiUrl = new URL(await this.resolveAampApiUrl());
+    apiUrl.searchParams.set("action", "aamp.mailbox.send");
+    const res = await fetch(apiUrl, {
       method: "POST",
       headers: {
         Authorization: `Basic ${this.config.authToken}`,
@@ -1008,11 +1179,13 @@ var SmtpSender = class {
    * store a reverse-index (messageId → taskId) for In-Reply-To thread routing.
    */
   async sendTask(opts) {
-    const taskId = randomUUID();
+    const taskId = opts.taskId ?? randomUUID();
     const aampHeaders = buildDispatchHeaders({
       taskId,
-      timeoutSecs: opts.timeoutSecs,
+      priority: opts.priority,
+      expiresAt: opts.expiresAt,
       contextLinks: opts.contextLinks ?? [],
+      dispatchContext: opts.dispatchContext,
       parentTaskId: opts.parentTaskId
     });
     const sendMailOpts = {
@@ -1022,7 +1195,8 @@ var SmtpSender = class {
       text: [
         `Task: ${opts.title}`,
         `Task ID: ${taskId}`,
-        opts.timeoutSecs ? `Deadline: ${opts.timeoutSecs}s` : `Deadline: none`,
+        `Priority: ${opts.priority ?? "normal"}`,
+        opts.expiresAt ? `Expires At: ${opts.expiresAt}` : `Expires At: none`,
         opts.contextLinks?.length ? `Context:
 ${opts.contextLinks.map((l) => `  ${l}`).join("\n")}` : "",
         opts.bodyText ?? "",
@@ -1111,7 +1285,7 @@ Error: ${opts.errorMsg}` : ""
     await this.transport.sendMail(mailOpts);
   }
   /**
-   * Send a task.help email when the agent is blocked
+   * Send a task.help_needed email when the agent is blocked
    */
   async sendHelp(opts) {
     const aampHeaders = buildHelpHeaders({
@@ -1165,6 +1339,35 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
     }
     await this.transport.sendMail(helpMailOpts);
   }
+  /**
+   * Send a task.cancel email to stop a previously dispatched task.
+   */
+  async sendCancel(opts) {
+    const aampHeaders = buildCancelHeaders({
+      taskId: opts.taskId
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Cancel] Task ${opts.taskId}`,
+      text: opts.bodyText ?? "The dispatcher cancelled this task.",
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      return;
+    }
+    await this.transport.sendMail(mailOpts);
+  }
   /**
    * Send a task.ack email to confirm receipt of a dispatch
    */
@@ -1192,6 +1395,59 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
     }
     await this.transport.sendMail(mailOpts);
   }
+  async sendCardQuery(opts) {
+    const taskId = opts.taskId ?? randomUUID();
+    const aampHeaders = buildCardQueryHeaders({ taskId });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Card Query] ${taskId}`,
+      text: opts.bodyText?.trim() || "Please share your agent card and capability details.",
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      return { taskId, messageId: info2.messageId ?? "" };
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    return { taskId, messageId: info.messageId ?? "" };
+  }
+  async sendCardResponse(opts) {
+    const aampHeaders = buildCardResponseHeaders({
+      taskId: opts.taskId,
+      summary: opts.summary
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Card] ${sanitize(opts.summary)}`,
+      text: opts.bodyText,
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      return;
+    }
+    await this.transport.sendMail(mailOpts);
+  }
   /**
    * Verify SMTP connection
    */
@@ -1209,56 +1465,68 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
 };
 
 // ../sdk/src/client.ts
-var AampClient = class extends TinyEmitter {
+var AampClient = class _AampClient extends TinyEmitter {
   jmapClient;
   smtpSender;
   config;
   constructor(config) {
     super();
     this.config = config;
+    const mailboxToken = config.mailboxToken;
+    const resolvedBaseUrl = config.baseUrl;
+    const derived = deriveMailboxServiceDefaults(config.email, resolvedBaseUrl);
+    const smtpHost = config.smtpHost ?? derived.smtpHost;
     let password;
     try {
-      const decoded = Buffer.from(config.jmapToken, "base64").toString("utf-8");
+      const decoded = Buffer.from(mailboxToken, "base64").toString("utf-8");
       const colonIdx = decoded.indexOf(":");
       if (colonIdx < 0)
-        throw new Error("Invalid jmapToken format: expected base64(email:password)");
+        throw new Error("Invalid mailboxToken format: expected base64(email:password)");
       password = decoded.slice(colonIdx + 1);
       if (!password)
-        throw new Error("Invalid jmapToken: empty password");
+        throw new Error("Invalid mailboxToken: empty password");
     } catch (err) {
-      if (err instanceof Error && err.message.startsWith("Invalid jmapToken"))
+      if (err instanceof Error && err.message.startsWith("Invalid mailboxToken"))
         throw err;
-      throw new Error(`Failed to decode jmapToken: ${err.message}`);
+      throw new Error(`Failed to decode mailboxToken: ${err.message}`);
     }
     this.jmapClient = new JmapPushClient({
       email: config.email,
       password: password ?? config.smtpPassword,
-      jmapUrl: config.jmapUrl,
+      jmapUrl: resolvedBaseUrl,
       reconnectInterval: config.reconnectInterval ?? 5e3,
       rejectUnauthorized: config.rejectUnauthorized
     });
     this.smtpSender = new SmtpSender({
-      host: config.smtpHost,
+      host: smtpHost,
       port: config.smtpPort ?? 587,
       user: config.email,
       password: config.smtpPassword,
-      httpBaseUrl: config.httpSendBaseUrl ?? config.jmapUrl,
-      authToken: config.jmapToken,
+      httpBaseUrl: config.httpSendBaseUrl ?? resolvedBaseUrl,
+      authToken: mailboxToken,
       rejectUnauthorized: config.rejectUnauthorized
     });
     this.jmapClient.on("task.dispatch", (task) => {
       this.emit("task.dispatch", task);
     });
+    this.jmapClient.on("task.cancel", (task) => {
+      this.emit("task.cancel", task);
+    });
     this.jmapClient.on("task.result", (result) => {
       this.emit("task.result", result);
     });
     this.jmapClient.on("task.help_needed", (help) => {
       this.emit("task.help_needed", help);
-      this.emit("task.help", help);
     });
     this.jmapClient.on("task.ack", (ack) => {
       this.emit("task.ack", ack);
     });
+    this.jmapClient.on("card.query", (query) => {
+      this.emit("card.query", query);
+    });
+    this.jmapClient.on("card.response", (response) => {
+      this.emit("card.response", response);
+    });
     this.jmapClient.on("_autoAck", async ({ to, taskId, messageId }) => {
       try {
         await this.smtpSender.sendAck({ to, taskId, inReplyTo: messageId });
@@ -1279,6 +1547,86 @@ var AampClient = class extends TinyEmitter {
       this.emit("error", err);
     });
   }
+  static fromMailboxIdentity(config) {
+    const derived = deriveMailboxServiceDefaults(config.email, config.baseUrl);
+    return new _AampClient({
+      email: config.email,
+      mailboxToken: Buffer.from(`${config.email}:${config.smtpPassword}`).toString("base64"),
+      baseUrl: derived.httpBaseUrl ?? `https://${config.email.split("@")[1] ?? "localhost"}`,
+      smtpHost: derived.smtpHost,
+      smtpPort: config.smtpPort ?? 587,
+      smtpPassword: config.smtpPassword,
+      reconnectInterval: config.reconnectInterval,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+  }
+  static async discoverAampService(aampHost) {
+    const base = aampHost.replace(/\/$/, "");
+    const res = await fetch(`${base}/.well-known/aamp`);
+    if (!res.ok) {
+      throw new Error(`AAMP discovery failed: ${res.status} ${res.statusText}`);
+    }
+    const discovery = await res.json();
+    if (!discovery.api?.url) {
+      throw new Error("AAMP discovery did not return api.url");
+    }
+    return discovery;
+  }
+  static async callDiscoveredApi(base, opts) {
+    const discovery = await _AampClient.discoverAampService(base);
+    const apiUrl = new URL(discovery.api.url, `${base}/`);
+    apiUrl.searchParams.set("action", opts.action);
+    for (const [key, value] of Object.entries(opts.query ?? {})) {
+      if (value == null)
+        continue;
+      apiUrl.searchParams.set(key, String(value));
+    }
+    return fetch(apiUrl, {
+      method: opts.method ?? "GET",
+      headers: {
+        ...opts.authToken ? { Authorization: `Basic ${opts.authToken}` } : {},
+        ...opts.body ? { "Content-Type": "application/json" } : {}
+      },
+      ...opts.body ? { body: JSON.stringify(opts.body) } : {}
+    });
+  }
+  static async registerMailbox(opts) {
+    const base = opts.aampHost.replace(/\/$/, "");
+    const registerRes = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.mailbox.register",
+      method: "POST",
+      body: {
+        slug: opts.slug,
+        description: opts.description
+      }
+    });
+    if (!registerRes.ok) {
+      const body = await registerRes.text().catch(() => "");
+      throw new Error(`Mailbox registration failed: ${registerRes.status} ${body || registerRes.statusText}`);
+    }
+    const registerData = await registerRes.json();
+    if (!registerData.registrationCode) {
+      throw new Error("Mailbox registration succeeded but no registrationCode was returned");
+    }
+    const credsRes = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.mailbox.credentials",
+      query: { code: registerData.registrationCode }
+    });
+    if (!credsRes.ok) {
+      const body = await credsRes.text().catch(() => "");
+      throw new Error(`Mailbox credential exchange failed: ${credsRes.status} ${body || credsRes.statusText}`);
+    }
+    const creds = await credsRes.json();
+    if (!creds.email || !creds.mailbox?.token || !creds.smtp?.password) {
+      throw new Error("Mailbox credential exchange returned an incomplete identity payload");
+    }
+    return {
+      email: creds.email,
+      mailboxToken: creds.mailbox.token,
+      smtpPassword: creds.smtp.password,
+      baseUrl: base
+    };
+  }
   // =====================================================
   // Lifecycle
   // =====================================================
@@ -1316,6 +1664,9 @@ var AampClient = class extends TinyEmitter {
   async sendTask(opts) {
     return this.smtpSender.sendTask(opts);
   }
+  async sendCancel(opts) {
+    return this.smtpSender.sendCancel(opts);
+  }
   /**
    * Send a task.result email (agent → system/dispatcher)
    */
@@ -1323,11 +1674,72 @@ var AampClient = class extends TinyEmitter {
     return this.smtpSender.sendResult(opts);
   }
   /**
-   * Send a task.help email when the agent needs human assistance
+   * Send a task.help_needed email when the agent needs human assistance
    */
   async sendHelp(opts) {
     return this.smtpSender.sendHelp(opts);
   }
+  async sendCardQuery(opts) {
+    return this.smtpSender.sendCardQuery(opts);
+  }
+  async sendCardResponse(opts) {
+    return this.smtpSender.sendCardResponse(opts);
+  }
+  async updateDirectoryProfile(opts) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.directory.upsert",
+      method: "POST",
+      authToken: mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Directory profile update failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return data.profile;
+  }
+  async listDirectory(opts = {}) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.directory.list",
+      authToken: mailboxToken,
+      query: {
+        scope: opts.scope,
+        includeSelf: opts.includeSelf,
+        limit: opts.limit
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Directory list failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return data.agents;
+  }
+  async searchDirectory(opts) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.directory.search",
+      authToken: mailboxToken,
+      query: {
+        q: opts.query,
+        scope: opts.scope,
+        includeSelf: opts.includeSelf,
+        limit: opts.limit
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Directory search failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return data.agents;
+  }
   /**
    * Download a blob (attachment) by its JMAP blobId.
    * Use this to retrieve attachment content from received TaskDispatch or TaskResult messages.
@@ -1341,8 +1753,8 @@ var AampClient = class extends TinyEmitter {
    * a flaky WebSocket path. Safe to call periodically; duplicate processing is
    * suppressed by the JMAP push client.
    */
-  async reconcileRecentEmails(limit) {
-    return this.jmapClient.reconcileRecentEmails(limit);
+  async reconcileRecentEmails(limit, opts) {
+    return this.jmapClient.reconcileRecentEmails(limit, opts);
   }
   /**
    * Verify SMTP connectivity
@@ -1362,15 +1774,22 @@ import { homedir } from "node:os";
 function defaultCredentialsPath() {
   return join(homedir(), ".openclaw", "extensions", "aamp-openclaw-plugin", ".credentials.json");
 }
+function defaultTaskStatePath() {
+  return join(homedir(), ".openclaw", "extensions", "aamp-openclaw-plugin", ".task-state.json");
+}
 function loadCachedIdentity(file) {
   const resolved = file ?? defaultCredentialsPath();
   if (!existsSync(resolved))
     return null;
   try {
     const parsed = JSON.parse(readFileSync(resolved, "utf-8"));
-    if (!parsed.email || !parsed.jmapToken || !parsed.smtpPassword)
+    if (!parsed.email || !parsed.mailboxToken || !parsed.smtpPassword)
       return null;
-    return parsed;
+    return {
+      email: parsed.email,
+      mailboxToken: parsed.mailboxToken,
+      smtpPassword: parsed.smtpPassword
+    };
   } catch {
     return null;
   }
@@ -1378,7 +1797,31 @@ function loadCachedIdentity(file) {
 function saveCachedIdentity(identity, file) {
   const resolved = file ?? defaultCredentialsPath();
   mkdirSync(dirname(resolved), { recursive: true });
-  writeFileSync(resolved, JSON.stringify(identity, null, 2), "utf-8");
+  writeFileSync(resolved, JSON.stringify({
+    email: identity.email,
+    mailboxToken: identity.mailboxToken,
+    smtpPassword: identity.smtpPassword
+  }, null, 2), "utf-8");
+}
+function loadTaskState(file) {
+  const resolved = file ?? defaultTaskStatePath();
+  if (!existsSync(resolved))
+    return { terminalTaskIds: [] };
+  try {
+    const parsed = JSON.parse(readFileSync(resolved, "utf-8"));
+    return {
+      terminalTaskIds: Array.isArray(parsed.terminalTaskIds) ? parsed.terminalTaskIds.filter(Boolean) : []
+    };
+  } catch {
+    return { terminalTaskIds: [] };
+  }
+}
+function saveTaskState(state, file) {
+  const resolved = file ?? defaultTaskStatePath();
+  mkdirSync(dirname(resolved), { recursive: true });
+  writeFileSync(resolved, JSON.stringify({
+    terminalTaskIds: state.terminalTaskIds ?? []
+  }, null, 2), "utf-8");
 }
 function ensureDir(dir) {
   mkdirSync(dir, { recursive: true });
@@ -1430,6 +1873,7 @@ function baseUrl(aampHost) {
   return `https://${aampHost}`;
 }
 var pendingTasks = /* @__PURE__ */ new Map();
+var terminalTaskIds = new Set(loadTaskState(defaultTaskStatePath()).terminalTaskIds ?? []);
 var dispatchedSubtasks = /* @__PURE__ */ new Map();
 var waitingDispatches = /* @__PURE__ */ new Map();
 var aampClient = null;
@@ -1456,10 +1900,83 @@ function logTransportState(api, mode, email, previousMode) {
   }
   api.logger.info(`[AAMP] Connected \u2014 listening as ${email}`);
 }
+function isSyntheticPendingKey(taskKey) {
+  return taskKey.startsWith("result:") || taskKey.startsWith("help:");
+}
+function saveTerminalTaskIds() {
+  saveTaskState({ terminalTaskIds: [...terminalTaskIds] }, defaultTaskStatePath());
+}
+function rememberTerminalTask(taskId) {
+  terminalTaskIds.add(taskId);
+  saveTerminalTaskIds();
+}
+function priorityRank(priority) {
+  switch (priority) {
+    case "urgent":
+      return 0;
+    case "high":
+      return 1;
+    default:
+      return 2;
+  }
+}
+function hasExpired(task) {
+  if (task.expiresAt) {
+    const expiresAtMs = new Date(task.expiresAt).getTime();
+    if (Number.isFinite(expiresAtMs) && Date.now() >= expiresAtMs)
+      return true;
+  }
+  return false;
+}
+function nextPendingEntry() {
+  const entries = [...pendingTasks.entries()];
+  const notifications = entries.filter(([key]) => key.startsWith("result:") || key.startsWith("help:"));
+  if (notifications.length > 0) {
+    return notifications.sort((a, b) => new Date(a[1].receivedAt).getTime() - new Date(b[1].receivedAt).getTime())[0];
+  }
+  return entries.filter(([key]) => !key.startsWith("result:") && !key.startsWith("help:")).sort((a, b) => {
+    const rankDiff = priorityRank(a[1].priority) - priorityRank(b[1].priority);
+    if (rankDiff !== 0)
+      return rankDiff;
+    return new Date(a[1].receivedAt).getTime() - new Date(b[1].receivedAt).getTime();
+  })[0];
+}
+function queuePendingTask(task) {
+  if (terminalTaskIds.has(task.taskId)) {
+    return false;
+  }
+  pendingTasks.set(task.taskId, {
+    taskId: task.taskId,
+    from: task.from,
+    title: task.title,
+    bodyText: task.bodyText ?? "",
+    priority: task.priority ?? "normal",
+    ...task.expiresAt ? { expiresAt: task.expiresAt } : {},
+    contextLinks: task.contextLinks ?? [],
+    messageId: task.messageId ?? "",
+    receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (hasExpired(pendingTasks.get(task.taskId))) {
+    pendingTasks.delete(task.taskId);
+    rememberTerminalTask(task.taskId);
+    return false;
+  }
+  return true;
+}
 async function registerNode(cfg) {
   const slug = (cfg.slug ?? "openclaw-agent").toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "");
   const base = baseUrl(cfg.aampHost);
-  const res = await fetch(`${base}/api/nodes/self-register`, {
+  const discoveryRes = await fetch(`${base}/.well-known/aamp`);
+  if (!discoveryRes.ok) {
+    throw new Error(`AAMP discovery failed (${discoveryRes.status}): ${discoveryRes.statusText}`);
+  }
+  const discovery = await discoveryRes.json();
+  const apiUrl = discovery.api?.url;
+  if (!apiUrl) {
+    throw new Error("AAMP discovery did not return api.url");
+  }
+  const apiBase = new URL(apiUrl, `${base}/`).toString();
+  const res = await fetch(`${apiBase}?action=aamp.mailbox.register`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ slug, description: "OpenClaw AAMP agent node" })
@@ -1470,7 +1987,7 @@ async function registerNode(cfg) {
   }
   const regData = await res.json();
   const credRes = await fetch(
-    `${base}/api/nodes/credentials?code=${encodeURIComponent(regData.registrationCode)}`
+    `${apiBase}?action=aamp.mailbox.credentials&code=${encodeURIComponent(regData.registrationCode)}`
   );
   if (!credRes.ok) {
     const err = await credRes.json().catch(() => ({}));
@@ -1479,7 +1996,7 @@ async function registerNode(cfg) {
   const credData = await credRes.json();
   return {
     email: credData.email,
-    jmapToken: credData.jmap.token,
+    mailboxToken: credData.mailbox.token,
     smtpPassword: credData.smtp.password
   };
 }
@@ -1644,13 +2161,10 @@ var src_default = {
       lastLoggedTransportMode = "disconnected";
       api.logger.info(`[AAMP] Mailbox identity ready \u2014 ${agentEmail}`);
       const base = baseUrl(cfg.aampHost);
-      aampClient = new AampClient({
+      aampClient = AampClient.fromMailboxIdentity({
         email: identity.email,
-        jmapToken: identity.jmapToken,
-        jmapUrl: base,
-        smtpHost: new URL(base).hostname,
-        smtpPort: 587,
         smtpPassword: identity.smtpPassword,
+        baseUrl: base,
         // Local/dev: management-service proxy uses plain HTTP, no TLS cert to verify.
         // Production: set to true when using wss:// with valid certs.
         rejectUnauthorized: false
@@ -1658,6 +2172,10 @@ var src_default = {
       aampClient.on("task.dispatch", (task) => {
         api.logger.info(`[AAMP] \u2190 task.dispatch  ${task.taskId}  "${task.title}"  from=${task.from}`);
         try {
+          if (terminalTaskIds.has(task.taskId)) {
+            api.logger.info(`[AAMP] Skipping already-terminal task ${task.taskId}`);
+            return;
+          }
           const decision = matchSenderPolicy(task, cfg.senderPolicies);
           if (!decision.allowed) {
             api.logger.warn(`[AAMP] \u2717 rejected by senderPolicies: ${task.from}  task=${task.taskId}  reason=${decision.reason}`);
@@ -1672,16 +2190,10 @@ var src_default = {
             });
             return;
           }
-          pendingTasks.set(task.taskId, {
-            taskId: task.taskId,
-            from: task.from,
-            title: task.title,
-            bodyText: task.bodyText ?? "",
-            contextLinks: task.contextLinks,
-            timeoutSecs: task.timeoutSecs,
-            messageId: task.messageId ?? "",
-            receivedAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
+          if (!queuePendingTask(task)) {
+            api.logger.info(`[AAMP] Ignoring already-terminal or expired task ${task.taskId}`);
+            return;
+          }
           wakeAgentForPendingTask(pendingTasks.get(task.taskId));
         } catch (err) {
           api.logger.error(`[AAMP] task.dispatch handler failed for ${task.taskId}: ${err.message}`);
@@ -1690,7 +2202,21 @@ var src_default = {
           }
         }
       });
+      aampClient.on("task.cancel", (cancel) => {
+        api.logger.info(`[AAMP] \u2190 task.cancel  ${cancel.taskId}  from=${cancel.from}`);
+        const removed = pendingTasks.delete(cancel.taskId);
+        pendingTasks.delete(`result:${cancel.taskId}`);
+        pendingTasks.delete(`help:${cancel.taskId}`);
+        dispatchedSubtasks.delete(cancel.taskId);
+        waitingDispatches.delete(cancel.taskId);
+        rememberTerminalTask(cancel.taskId);
+        if (removed) {
+          api.logger.info(`[AAMP] Cancelled task ${cancel.taskId} \u2014 removed from pending queue`);
+        }
+      });
       aampClient.on("task.result", (result) => {
+        if (result.from.toLowerCase() === agentEmail.toLowerCase())
+          return;
         api.logger.info(`[AAMP] \u2190 task.result  ${result.taskId}  status=${result.status}  from=${result.from}`);
         const sub = dispatchedSubtasks.get(result.taskId);
         dispatchedSubtasks.delete(result.taskId);
@@ -1754,8 +2280,8 @@ Output:
 ${truncatedOutput}${attachmentInfo}` : `Agent ${result.from} rejected the sub-task.
 
 Reason: ${result.errorMsg ?? "unknown"}`,
+            priority: "urgent",
             contextLinks: [],
-            timeoutSecs: 0,
             messageId: "",
             receivedAt: (/* @__PURE__ */ new Date()).toISOString()
           });
@@ -1817,6 +2343,8 @@ ${notifyBody?.bodyText ?? "Sub-task completed."}${actionSection}`;
         });
       });
       aampClient.on("task.help_needed", (help) => {
+        if (help.from.toLowerCase() === agentEmail.toLowerCase())
+          return;
         api.logger.info(`[AAMP] \u2190 task.help_needed  ${help.taskId}  question="${help.question}"  from=${help.from}`);
         const waiter = waitingDispatches.get(help.taskId);
         if (waiter) {
@@ -1835,8 +2363,8 @@ ${notifyBody?.bodyText ?? "Sub-task completed."}${actionSection}`;
 Question: ${help.question}
 Blocked reason: ${help.blockedReason}${help.suggestedOptions?.length ? `
 Suggested options: ${help.suggestedOptions.join(", ")}` : ""}`,
+          priority: "urgent",
           contextLinks: [],
-          timeoutSecs: 0,
           messageId: "",
           receivedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
@@ -1938,6 +2466,10 @@ ${notifyBody?.bodyText ?? help.question}`;
         lastTransportMode = mode;
         lastLoggedTransportMode = mode;
       }, 1e3);
+      void aampClient.reconcileRecentEmails(100, { includeHistorical: true }).catch((err) => {
+        lastConnectionError = err.message;
+        api.logger.warn(`[AAMP] Startup mailbox reconcile failed: ${err.message}`);
+      });
       transportMonitorTimer = setInterval(() => {
         if (!aampClient)
           return;
@@ -1955,7 +2487,7 @@ ${notifyBody?.bodyText ?? help.question}`;
       reconcileTimer = setInterval(() => {
         if (!aampClient)
           return;
-        void aampClient.reconcileRecentEmails(20).catch((err) => {
+        void aampClient.reconcileRecentEmails(100).catch((err) => {
           lastConnectionError = err.message;
           api.logger.warn(`[AAMP] Mailbox reconcile failed: ${err.message}`);
         });
@@ -2009,24 +2541,45 @@ ${notifyBody?.bodyText ?? help.question}`;
         if (ctx?.sessionKey && !String(ctx.sessionKey).startsWith("aamp:")) {
           currentSessionKey = ctx.sessionKey;
         }
-        const now = Date.now();
         for (const [id, t] of pendingTasks) {
-          if (t.timeoutSecs && now - new Date(t.receivedAt).getTime() > t.timeoutSecs * 1e3) {
-            api.logger.warn(`[AAMP] Task ${id} timed out \u2014 removing from queue`);
+          if (hasExpired(t)) {
+            if (!isSyntheticPendingKey(id) && aampClient?.isConnected()) {
+              void aampClient.sendResult({
+                to: t.from,
+                taskId: t.taskId,
+                status: "rejected",
+                output: "",
+                errorMsg: t.expiresAt ? "Task expired before the agent could complete it." : "Task timed out while waiting for agent completion or follow-up input.",
+                inReplyTo: t.messageId || void 0
+              }).then(() => {
+                rememberTerminalTask(t.taskId);
+                api.logger.warn(`[AAMP] Task ${id} expired \u2014 sent rejected result to dispatcher`);
+              }).catch((err) => {
+                api.logger.error(`[AAMP] Task ${id} expired \u2014 failed to notify dispatcher: ${err.message}`);
+              });
+            } else {
+              rememberTerminalTask(t.taskId);
+              api.logger.warn(`[AAMP] Task ${id} expired \u2014 removing from queue`);
+            }
             pendingTasks.delete(id);
           }
         }
         if (pendingTasks.size === 0)
           return {};
-        const allEntries = [...pendingTasks.entries()];
-        const notifications = allEntries.filter(([key]) => key.startsWith("result:") || key.startsWith("help:"));
-        const actionable = allEntries.filter(([key]) => !key.startsWith("result:") && !key.startsWith("help:"));
-        const [taskKey, task] = notifications.length > 0 ? notifications.sort((a, b) => new Date(a[1].receivedAt).getTime() - new Date(b[1].receivedAt).getTime())[0] : actionable.sort((a, b) => new Date(a[1].receivedAt).getTime() - new Date(b[1].receivedAt).getTime())[0];
+        const nextEntry = nextPendingEntry();
+        if (!nextEntry)
+          return {};
+        const [taskKey, task] = nextEntry;
         const isNotification = taskKey.startsWith("result:") || taskKey.startsWith("help:");
         if (isNotification && taskKey) {
           pendingTasks.delete(taskKey);
         }
-        const actionableTasks = [...pendingTasks.entries()].filter(([key]) => !key.startsWith("result:") && !key.startsWith("help:")).map(([, t]) => t);
+        const actionableTasks = [...pendingTasks.entries()].filter(([key]) => !key.startsWith("result:") && !key.startsWith("help:")).map(([, t]) => t).sort((a, b) => {
+          const rankDiff = priorityRank(a.priority) - priorityRank(b.priority);
+          if (rankDiff !== 0)
+            return rankDiff;
+          return new Date(a.receivedAt).getTime() - new Date(b.receivedAt).getTime();
+        });
         const hasAttachmentInfo = isNotification && (task.bodyText?.includes("aamp_download_attachment") ?? false);
         const actionRequiredSection = isNotification && actionableTasks.length > 0 ? [
           ``,
@@ -2036,7 +2589,7 @@ ${notifyBody?.bodyText ?? help.question}`;
           `Use the sub-task result above to complete them by calling aamp_send_result.`,
           ``,
           ...actionableTasks.map(
-            (t) => `- Task ID: ${t.taskId} | From: ${t.from} | Title: "${t.title}"`
+            (t) => `- [${t.priority}] Task ID: ${t.taskId} | From: ${t.from} | Title: "${t.title}"`
           ),
           ...hasAttachmentInfo ? [
             ``,
@@ -2054,6 +2607,7 @@ ${notifyBody?.bodyText ?? help.question}`;
           `If the sub-task included attachments, use aamp_download_attachment to fetch them.`,
           ``,
           `Task ID:  ${task.taskId}`,
+          `Priority: ${task.priority}`,
           `From:     ${task.from}`,
           `Title:    ${task.title}`,
           task.bodyText ? `
@@ -2096,7 +2650,7 @@ ${task.bodyText}` : "",
 ${task.bodyText}` : "",
           task.contextLinks.length ? `Context Links:
 ${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
-          task.timeoutSecs ? `Deadline: ${task.timeoutSecs}s from dispatch` : `Deadline: none`,
+          task.expiresAt ? `Expires: ${task.expiresAt}` : `Expires: none`,
           `Received: ${task.receivedAt}`,
           pendingTasks.size > 1 ? `
 (+${pendingTasks.size - 1} more tasks queued)` : ""
@@ -2215,6 +2769,7 @@ ${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
           attachments
         });
         pendingTasks.delete(task.taskId);
+        rememberTerminalTask(task.taskId);
         api.logger.info(`[AAMP] \u2192 task.result  ${task.taskId}  ${p.status}`);
         if (pendingTasks.size > 0) {
           try {
@@ -2296,8 +2851,13 @@ ${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
         if (pendingTasks.size === 0) {
           return { content: [{ type: "text", text: "No pending AAMP tasks." }] };
         }
-        const lines = [...pendingTasks.values()].sort((a, b) => new Date(a.receivedAt).getTime() - new Date(b.receivedAt).getTime()).map(
-          (t, i) => `${i + 1}. [${t.taskId}] "${t.title}"${t.bodyText ? `
+        const lines = [...pendingTasks.values()].sort((a, b) => {
+          const rankDiff = priorityRank(a.priority) - priorityRank(b.priority);
+          if (rankDiff !== 0)
+            return rankDiff;
+          return new Date(a.receivedAt).getTime() - new Date(b.receivedAt).getTime();
+        }).map(
+          (t, i) => `${i + 1}. [${t.priority}] [${t.taskId}] "${t.title}"${t.bodyText ? `
    Description: ${t.bodyText}` : ""} \u2014 from ${t.from} (received ${t.receivedAt})`
         );
         return {
@@ -2311,6 +2871,40 @@ ${lines.join("\n")}`
         };
       }
     }, { name: "aamp_pending_tasks" });
+    api.registerTool({
+      name: "aamp_cancel_task",
+      description: "Cancel a pending AAMP task and notify the dispatcher.",
+      parameters: {
+        type: "object",
+        required: ["taskId"],
+        properties: {
+          taskId: { type: "string", description: "The AAMP task ID to cancel." },
+          bodyText: { type: "string", description: "Optional cancellation note sent in the email body." }
+        }
+      },
+      execute: async (_id, params) => {
+        const p = params;
+        const task = pendingTasks.get(p.taskId);
+        if (!task) {
+          return { content: [{ type: "text", text: `Error: task ${p.taskId} not found in pending queue.` }] };
+        }
+        if (!aampClient?.isConnected()) {
+          return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
+        }
+        await aampClient.sendCancel({
+          to: task.from,
+          taskId: task.taskId,
+          bodyText: p.bodyText,
+          inReplyTo: task.messageId || void 0
+        });
+        pendingTasks.delete(task.taskId);
+        rememberTerminalTask(task.taskId);
+        api.logger.info(`[AAMP] \u2192 task.cancel  ${task.taskId}`);
+        return {
+          content: [{ type: "text", text: `Cancellation sent for task ${task.taskId}.` }]
+        };
+      }
+    }, { name: "aamp_cancel_task" });
     api.registerTool({
       name: "aamp_dispatch_task",
       description: "Send a task to another AAMP agent and WAIT for the result. This tool blocks until the sub-agent replies (typically 5-60s). The sub-agent's output and any attachment file paths are returned directly.",
@@ -2322,7 +2916,8 @@ ${lines.join("\n")}`
           title: { type: "string", description: "Task title (concise summary)" },
           bodyText: { type: "string", description: "Detailed task description" },
           parentTaskId: { type: "string", description: "If you are processing a pending AAMP task, pass its Task ID here to establish parent-child nesting. Omit for top-level tasks." },
-          timeoutSecs: { type: "number", description: "Timeout in seconds (optional)" },
+          priority: { type: "string", enum: ["urgent", "high", "normal"], description: "Task priority (optional)" },
+          expiresAt: { type: "string", description: "Absolute expiry time in ISO 8601 format (optional)" },
           contextLinks: {
             type: "array",
             items: { type: "string" },
@@ -2360,7 +2955,8 @@ ${lines.join("\n")}`
             to: params.to,
             title: params.title,
             parentTaskId: params.parentTaskId,
-            timeoutSecs: params.timeoutSecs,
+            priority: params.priority,
+            expiresAt: params.expiresAt,
             contextLinks: params.contextLinks,
             attachments
           });
@@ -2371,12 +2967,14 @@ ${lines.join("\n")}`
             parentTaskId: params.parentTaskId
           });
           api.logger.info(`[AAMP] \u2192 task.dispatch  ${result.taskId}  to=${params.to}  parent=${params.parentTaskId ?? "none"}  (waiting for reply\u2026)`);
-          const timeoutMs = (params.timeoutSecs ?? 300) * 1e3;
+          const timeoutMs = params.expiresAt ? Math.max(new Date(params.expiresAt).getTime() - Date.now(), 1) : 300 * 1e3;
           const reply = await new Promise((resolve, reject) => {
             waitingDispatches.set(result.taskId, resolve);
             setTimeout(() => {
               if (waitingDispatches.delete(result.taskId)) {
-                reject(new Error(`Sub-task ${result.taskId} timed out after ${params.timeoutSecs ?? 300}s`));
+                reject(new Error(
+                  params.expiresAt ? `Sub-task ${result.taskId} expired before a reply was received` : `Sub-task ${result.taskId} timed out after 300s`
+                ));
               }
             }, timeoutMs);
           });
@@ -2478,7 +3076,8 @@ Question: ${h.question}`,
           const apiUrl = discovery.api?.url;
           if (!apiUrl)
             throw new Error("AAMP discovery did not return api.url");
-          const res = await fetch(`${base}${apiUrl}?action=aamp.mailbox.check&email=${encodeURIComponent(email)}`);
+          const apiBase = new URL(apiUrl, `${base}/`).toString();
+          const res = await fetch(`${apiBase}?action=aamp.mailbox.check&email=${encodeURIComponent(email)}`);
           if (!res.ok)
             throw new Error(`HTTP ${res.status}`);
           const data = await res.json();
@@ -2558,6 +3157,11 @@ Question: ${h.question}`,
   }
 };
 export {
-  src_default as default
+  baseUrl,
+  src_default as default,
+  matchSenderPolicy,
+  queuePendingTask,
+  registerNode,
+  resolveIdentity
 };
 //# sourceMappingURL=index.js.map