aamp-openclaw-plugin 0.1.29 → 0.1.31

package/dist/index.js

@@ -1,8 +1,8 @@
-// ../sdk/src/jmap-push.ts
+// ../sdk/src/jmap-push.js
 import WebSocket from "ws";
 
-// ../sdk/src/types.ts
-var AAMP_PROTOCOL_VERSION = "1.0";
+// ../sdk/src/types.js
+var AAMP_PROTOCOL_VERSION = "1.1";
 var AAMP_HEADER = {
   VERSION: "X-AAMP-Version",
   INTENT: "X-AAMP-Intent",
@@ -18,11 +18,12 @@ var AAMP_HEADER = {
   QUESTION: "X-AAMP-Question",
   BLOCKED_REASON: "X-AAMP-BlockedReason",
   SUGGESTED_OPTIONS: "X-AAMP-SuggestedOptions",
+  STREAM_ID: "X-AAMP-Stream-Id",
   PARENT_TASK_ID: "X-AAMP-ParentTaskId",
   CARD_SUMMARY: "X-AAMP-Card-Summary"
 };
 
-// ../sdk/src/parser.ts
+// ../sdk/src/parser.js
 function normalizeBodyText(value) {
   return value?.replace(/\r\n/g, "\n").trim() ?? "";
 }
@@ -33,10 +34,7 @@ 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 pattern = new RegExp(`(?:^|\\n)${escapeRegex(label)}:\\s*([\\s\\S]*?)${nextPattern}`, "i");
   const match = pattern.exec(bodyText);
   return match?.[1]?.trim() ?? "";
 }
@@ -63,9 +61,7 @@ function parseTaskHelpBody(bodyText) {
   }
   const question = extractBodySection(normalized, "Question", ["Blocked reason", "Suggested options"]);
   const blockedReason = extractBodySection(normalized, "Blocked reason", ["Suggested options"]);
-  const suggestedOptions = parseSuggestedOptionsBlock(
-    extractBodySection(normalized, "Suggested options", [])
-  );
+  const suggestedOptions = parseSuggestedOptionsBlock(extractBodySection(normalized, "Suggested options", []));
   if (question || blockedReason || suggestedOptions.length) {
     return { question, blockedReason, suggestedOptions };
   }
@@ -83,10 +79,7 @@ function decodeMimeEncodedWordSegment(segment) {
       const buf = Buffer.from(body, "base64");
       return buf.toString(charset === "utf-8" || charset === "utf8" ? "utf8" : "utf8");
     }
-    const normalized = body.replace(/_/g, " ").replace(
-      /=([0-9A-Fa-f]{2})/g,
-      (_, hex) => String.fromCharCode(parseInt(hex, 16))
-    );
+    const normalized = body.replace(/_/g, " ").replace(/=([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
     const bytes = Buffer.from(normalized, "binary");
     return bytes.toString(charset === "utf-8" || charset === "utf8" ? "utf8" : "utf8");
   } catch {
@@ -97,19 +90,14 @@ function decodeMimeEncodedWords(value) {
   if (!value || !value.includes("=?"))
     return value ?? "";
   const collapsed = value.replace(/\r?\n[ \t]+/g, " ");
-  const decoded = collapsed.replace(
-    /=\?[^?]+\?[bBqQ]\?[^?]*\?=/g,
-    (segment) => decodeMimeEncodedWordSegment(segment)
-  );
+  const decoded = collapsed.replace(/=\?[^?]+\?[bBqQ]\?[^?]*\?=/g, (segment) => decodeMimeEncodedWordSegment(segment));
   return decoded.replace(/\s{2,}/g, " ").trim();
 }
 function normalizeHeaders(headers) {
-  return Object.fromEntries(
-    Object.entries(headers).map(([k, v]) => [
-      k.toLowerCase(),
-      Array.isArray(v) ? v[0] : v
-    ])
-  );
+  return Object.fromEntries(Object.entries(headers).map(([k, v]) => [
+    k.toLowerCase(),
+    Array.isArray(v) ? v[0] : v
+  ]));
 }
 function getAampHeader(headers, headerName) {
   return headers[headerName.toLowerCase()];
@@ -182,9 +170,7 @@ function parseAampHeaders(meta) {
   const decodedSubject = decodeMimeEncodedWords(meta.subject);
   if (intent === "task.dispatch") {
     const contextLinksStr = getAampHeader(headers, AAMP_HEADER.CONTEXT_LINKS) ?? "";
-    const dispatchContext = parseDispatchContextHeader(
-      getAampHeader(headers, AAMP_HEADER.DISPATCH_CONTEXT)
-    );
+    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);
@@ -225,9 +211,7 @@ function parseAampHeaders(meta) {
     const status = getAampHeader(headers, AAMP_HEADER.STATUS) ?? "completed";
     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)
-    );
+    const structuredResult = decodeStructuredResult(getAampHeader(headers, AAMP_HEADER.STRUCTURED_RESULT));
     const result = {
       protocolVersion,
       intent: "task.result",
@@ -271,6 +255,21 @@ function parseAampHeaders(meta) {
     };
     return ack;
   }
+  if (intent === "task.stream.opened") {
+    const streamId = getAampHeader(headers, AAMP_HEADER.STREAM_ID) ?? "";
+    if (!streamId)
+      return null;
+    const streamOpened = {
+      protocolVersion,
+      intent: "task.stream.opened",
+      taskId,
+      streamId,
+      from,
+      to,
+      messageId: meta.messageId
+    };
+    return streamOpened;
+  }
   if (intent === "card.query") {
     const cardQuery = {
       protocolVersion,
@@ -337,6 +336,14 @@ function buildAckHeaders(opts) {
     [AAMP_HEADER.TASK_ID]: opts.taskId
   };
 }
+function buildStreamOpenedHeaders(opts) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.stream.opened",
+    [AAMP_HEADER.TASK_ID]: opts.taskId,
+    [AAMP_HEADER.STREAM_ID]: opts.streamId
+  };
+}
 function buildResultHeaders(params) {
   const headers = {
     [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
@@ -374,7 +381,7 @@ function buildCardResponseHeaders(params) {
   };
 }
 
-// ../sdk/src/tiny-emitter.ts
+// ../sdk/src/tiny-emitter.js
 var TinyEmitter = class {
   listeners = /* @__PURE__ */ new Map();
   onceWrappers = /* @__PURE__ */ new WeakMap();
@@ -416,7 +423,7 @@ var TinyEmitter = class {
   }
 };
 
-// ../sdk/src/jmap-push.ts
+// ../sdk/src/jmap-push.js
 function describeError(err) {
   if (!(err instanceof Error))
     return String(err);
@@ -675,6 +682,9 @@ var JmapPushClient = class extends TinyEmitter {
         case "task.ack":
           this.emit("task.ack", aampMsg);
           break;
+        case "task.stream.opened":
+          this.emit("task.stream.opened", aampMsg);
+          break;
         case "card.query":
           this.emit("card.query", aampMsg);
           break;
@@ -773,12 +783,7 @@ var JmapPushClient = class extends TinyEmitter {
       this.connecting = false;
       const headerSummary = Object.entries(res.headers).map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(", ") : value ?? ""}`).join("; ");
       this.startPolling(`websocket handshake failed: ${res.statusCode ?? "unknown"}`);
-      this.emit(
-        "error",
-        new Error(
-          `JMAP WebSocket handshake failed: ${res.statusCode ?? "unknown"} ${res.statusMessage ?? ""}${headerSummary ? ` | headers: ${headerSummary}` : ""}`
-        )
-      );
+      this.emit("error", new Error(`JMAP WebSocket handshake failed: ${res.statusCode ?? "unknown"} ${res.statusMessage ?? ""}${headerSummary ? ` | headers: ${headerSummary}` : ""}`));
       this.scheduleReconnect();
     });
     this.ws.on("open", async () => {
@@ -790,13 +795,11 @@ var JmapPushClient = class extends TinyEmitter {
       if (accountId && this.emailState === null) {
         await this.initEmailState(accountId);
       }
-      this.ws.send(
-        JSON.stringify({
-          "@type": "WebSocketPushEnable",
-          dataTypes: ["Email"],
-          pushState: null
-        })
-      );
+      this.ws.send(JSON.stringify({
+        "@type": "WebSocketPushEnable",
+        dataTypes: ["Email"],
+        pushState: null
+      }));
       this.emit("connected");
     });
     this.ws.on("pong", () => {
@@ -985,23 +988,15 @@ var JmapPushClient = class extends TinyEmitter {
         return Buffer.from(arrayBuffer);
       }
       if (attempt < maxAttempts && (res.status === 404 || res.status === 429 || res.status === 503)) {
-        console.warn(
-          `[AAMP-SDK] blob download retry status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`
-        );
+        console.warn(`[AAMP-SDK] blob download retry status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`);
         const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 15e3);
         await new Promise((r) => setTimeout(r, delay));
         continue;
       }
-      console.error(
-        `[AAMP-SDK] blob download failed status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`
-      );
-      throw new Error(
-        `Blob download failed: status=${res.status} attempt=${attempt}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`
-      );
+      console.error(`[AAMP-SDK] blob download failed status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`);
+      throw new Error(`Blob download failed: status=${res.status} attempt=${attempt}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`);
     }
-    throw new Error(
-      `Blob download failed after retries: status=${lastStatus ?? "unknown"} attempt=${maxAttempts}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`
-    );
+    throw new Error(`Blob download failed after retries: status=${lastStatus ?? "unknown"} attempt=${maxAttempts}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`);
   }
   /**
    * Actively reconcile recent mailbox contents via JMAP HTTP.
@@ -1063,7 +1058,7 @@ var JmapPushClient = class extends TinyEmitter {
   }
 };
 
-// ../sdk/src/smtp-sender.ts
+// ../sdk/src/smtp-sender.js
 import { createTransport } from "nodemailer";
 import { randomUUID } from "crypto";
 var sanitize = (s) => s.replace(/[\r\n]/g, " ").trim();
@@ -1077,23 +1072,11 @@ function deriveMailboxServiceDefaults(email, baseUrl2) {
   };
 }
 var SmtpSender = class _SmtpSender {
-  constructor(config) {
-    this.config = config;
-    this.transport = createTransport({
-      host: config.host,
-      port: config.port,
-      secure: config.secure ?? false,
-      auth: {
-        user: config.user,
-        pass: config.password
-      },
-      tls: {
-        rejectUnauthorized: config.rejectUnauthorized ?? true
-      }
-    });
-  }
+  config;
   transport;
   discoveredApiUrlPromise = null;
+  jmapSessionPromise = null;
+  sentMailboxIdPromise = null;
   static fromMailboxIdentity(config) {
     const derived = deriveMailboxServiceDefaults(config.email, config.baseUrl);
     return new _SmtpSender({
@@ -1107,6 +1090,21 @@ var SmtpSender = class _SmtpSender {
       rejectUnauthorized: config.rejectUnauthorized
     });
   }
+  constructor(config) {
+    this.config = config;
+    this.transport = createTransport({
+      host: config.host,
+      port: config.port,
+      secure: config.secure ?? false,
+      auth: {
+        user: config.user,
+        pass: config.password
+      },
+      tls: {
+        rejectUnauthorized: config.rejectUnauthorized ?? true
+      }
+    });
+  }
   senderDomain() {
     return this.config.user.split("@")[1]?.toLowerCase() ?? "";
   }
@@ -1114,9 +1112,7 @@ var SmtpSender = class _SmtpSender {
     return email.split("@")[1]?.toLowerCase() ?? "";
   }
   shouldUseHttpFallback(to) {
-    return Boolean(
-      this.config.httpBaseUrl && this.config.authToken && this.senderDomain() && this.senderDomain() === this.recipientDomain(to)
-    );
+    return Boolean(this.config.httpBaseUrl && this.config.authToken && this.senderDomain() && this.senderDomain() === this.recipientDomain(to));
   }
   async resolveAampApiUrl() {
     const base = this.config.httpBaseUrl?.replace(/\/$/, "");
@@ -1173,6 +1169,134 @@ var SmtpSender = class _SmtpSender {
     }
     return { messageId: data.messageId };
   }
+  canPersistSentCopy() {
+    return Boolean(this.config.httpBaseUrl && this.config.authToken);
+  }
+  getJmapAuthHeader() {
+    if (!this.config.authToken) {
+      throw new Error("JMAP auth token is not configured");
+    }
+    return `Basic ${this.config.authToken}`;
+  }
+  async resolveJmapSession() {
+    const base = this.config.httpBaseUrl?.replace(/\/$/, "");
+    if (!base) {
+      throw new Error("JMAP base URL is not configured");
+    }
+    if (!this.jmapSessionPromise) {
+      this.jmapSessionPromise = (async () => {
+        const res = await fetch(`${base}/.well-known/jmap`, {
+          headers: { Authorization: this.getJmapAuthHeader() }
+        });
+        if (!res.ok) {
+          throw new Error(`JMAP session failed: ${res.status} ${res.statusText}`);
+        }
+        const session = await res.json();
+        const accountId = session.primaryAccounts?.["urn:ietf:params:jmap:mail"] ?? Object.keys(session.accounts ?? {})[0];
+        if (!accountId) {
+          throw new Error("No JMAP mail account available");
+        }
+        return {
+          accountId,
+          apiUrl: `${base}/jmap/`
+        };
+      })();
+    }
+    try {
+      return await this.jmapSessionPromise;
+    } catch (err) {
+      this.jmapSessionPromise = null;
+      throw err;
+    }
+  }
+  async jmapCall(methodCalls) {
+    const session = await this.resolveJmapSession();
+    const res = await fetch(session.apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: this.getJmapAuthHeader(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        using: [
+          "urn:ietf:params:jmap:core",
+          "urn:ietf:params:jmap:mail"
+        ],
+        methodCalls: methodCalls.map(([name, args, tag]) => [
+          name,
+          { accountId: session.accountId, ...args },
+          tag
+        ])
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`JMAP API call failed: ${res.status}`);
+    }
+    const data = await res.json();
+    return data.methodResponses ?? [];
+  }
+  async getSentMailboxId() {
+    if (!this.sentMailboxIdPromise) {
+      this.sentMailboxIdPromise = (async () => {
+        const responses = await this.jmapCall([
+          ["Mailbox/get", { ids: null }, "mb1"]
+        ]);
+        const result = responses.find(([name]) => name === "Mailbox/get")?.[1];
+        const mailboxes = result?.list ?? [];
+        return mailboxes.find((mailbox) => mailbox.role === "sent")?.id ?? mailboxes[0]?.id ?? null;
+      })();
+    }
+    try {
+      return await this.sentMailboxIdPromise;
+    } catch (err) {
+      this.sentMailboxIdPromise = null;
+      throw err;
+    }
+  }
+  async saveToSent(params) {
+    if (!this.canPersistSentCopy())
+      return;
+    const sentMailboxId = await this.getSentMailboxId();
+    if (!sentMailboxId)
+      return;
+    const emailCreate = {
+      mailboxIds: { [sentMailboxId]: true },
+      from: [{ email: params.from }],
+      to: [{ email: params.to }],
+      subject: params.subject,
+      bodyValues: {
+        body: {
+          value: params.text,
+          charset: "utf-8"
+        }
+      },
+      textBody: [{ partId: "body", type: "text/plain" }],
+      keywords: { "$seen": true }
+    };
+    if (params.inReplyTo) {
+      emailCreate["header:In-Reply-To:asText"] = ` ${sanitize(params.inReplyTo)}`;
+    }
+    if (params.messageId) {
+      emailCreate["header:Message-ID:asText"] = ` ${sanitize(params.messageId)}`;
+    }
+    if (params.references) {
+      emailCreate["header:References:asText"] = ` ${sanitize(params.references)}`;
+    }
+    for (const [name, value] of Object.entries(params.aampHeaders)) {
+      emailCreate[`header:${name}:asText`] = ` ${value}`;
+    }
+    await this.jmapCall([
+      ["Email/set", { create: { sent1: emailCreate } }, "sent1"]
+    ]);
+  }
+  async saveToSentBestEffort(params) {
+    if (!this.canPersistSentCopy())
+      return;
+    try {
+      await this.saveToSent(params);
+    } catch {
+    }
+  }
   /**
    * Send a task.dispatch email.
    * Returns both the generated taskId and the SMTP Message-ID so callers can
@@ -1224,9 +1348,25 @@ ${opts.contextLinks.map((l) => `  ${l}`).join("\n")}` : "",
           content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
         }))
       });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: sendMailOpts.subject,
+        text: sendMailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId
+      });
       return { taskId, messageId: info2.messageId ?? "" };
     }
     const info = await this.transport.sendMail(sendMailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: sendMailOpts.subject,
+      text: sendMailOpts.text,
+      aampHeaders,
+      messageId: info.messageId
+    });
     return { taskId, messageId: info.messageId ?? "" };
   }
   /**
@@ -1269,7 +1409,7 @@ Error: ${opts.errorMsg}` : ""
       }));
     }
     if (this.shouldUseHttpFallback(opts.to)) {
-      await this.sendViaHttp({
+      const info2 = await this.sendViaHttp({
         to: opts.to,
         subject: mailOpts.subject,
         text: mailOpts.text,
@@ -1280,9 +1420,29 @@ Error: ${opts.errorMsg}` : ""
           content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
         }))
       });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
       return;
     }
-    await this.transport.sendMail(mailOpts);
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
   }
   /**
    * Send a task.help_needed email when the agent is blocked
@@ -1324,7 +1484,7 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
       }));
     }
     if (this.shouldUseHttpFallback(opts.to)) {
-      await this.sendViaHttp({
+      const info2 = await this.sendViaHttp({
         to: opts.to,
         subject: helpMailOpts.subject,
         text: helpMailOpts.text,
@@ -1335,9 +1495,29 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
           content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
         }))
       });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: helpMailOpts.subject,
+        text: helpMailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
       return;
     }
-    await this.transport.sendMail(helpMailOpts);
+    const info = await this.transport.sendMail(helpMailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: helpMailOpts.subject,
+      text: helpMailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
   }
   /**
    * Send a task.cancel email to stop a previously dispatched task.
@@ -1358,15 +1538,35 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
       mailOpts.references = opts.inReplyTo;
     }
     if (this.shouldUseHttpFallback(opts.to)) {
-      await this.sendViaHttp({
+      const info2 = await this.sendViaHttp({
         to: opts.to,
         subject: mailOpts.subject,
         text: mailOpts.text,
         aampHeaders
       });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
       return;
     }
-    await this.transport.sendMail(mailOpts);
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
   }
   /**
    * Send a task.ack email to confirm receipt of a dispatch
@@ -1385,15 +1585,85 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
       mailOpts.references = opts.inReplyTo;
     }
     if (this.shouldUseHttpFallback(opts.to)) {
-      await this.sendViaHttp({
+      const info2 = await this.sendViaHttp({
         to: opts.to,
         subject: mailOpts.subject,
         text: mailOpts.text,
         aampHeaders
       });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
       return;
     }
-    await this.transport.sendMail(mailOpts);
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+  }
+  async sendStreamOpened(opts) {
+    const aampHeaders = buildStreamOpenedHeaders({
+      taskId: opts.taskId,
+      streamId: opts.streamId
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Stream] Task ${opts.taskId}`,
+      text: `AAMP task stream is ready.
+
+Task ID: ${opts.taskId}
+Stream ID: ${opts.streamId}`,
+      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
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return;
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
   }
   async sendCardQuery(opts) {
     const taskId = opts.taskId ?? randomUUID();
@@ -1416,9 +1686,29 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
         text: mailOpts.text,
         aampHeaders
       });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
       return { taskId, messageId: info2.messageId ?? "" };
     }
     const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
     return { taskId, messageId: info.messageId ?? "" };
   }
   async sendCardResponse(opts) {
@@ -1438,15 +1728,35 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
       mailOpts.references = opts.inReplyTo;
     }
     if (this.shouldUseHttpFallback(opts.to)) {
-      await this.sendViaHttp({
+      const info2 = await this.sendViaHttp({
         to: opts.to,
         subject: mailOpts.subject,
         text: mailOpts.text,
         aampHeaders
       });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
       return;
     }
-    await this.transport.sendMail(mailOpts);
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
   }
   /**
    * Verify SMTP connection
@@ -1464,11 +1774,66 @@ ${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
   }
 };
 
-// ../sdk/src/client.ts
+// ../sdk/src/thread.js
+function singleLine(value, maxLength = 220) {
+  const normalized = (value ?? "").replace(/\s+/g, " ").trim();
+  if (!normalized)
+    return "";
+  if (normalized.length <= maxLength)
+    return normalized;
+  return `${normalized.slice(0, maxLength - 1)}\u2026`;
+}
+function formatTimestamp(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()))
+    return value;
+  return date.toISOString().slice(0, 16).replace("T", " ");
+}
+function renderEventLine(event) {
+  const from = event.from.split("@")[0] || event.from;
+  const timestamp = formatTimestamp(event.createdAt);
+  if (event.intent === "task.dispatch") {
+    const summary = singleLine(event.bodyText) || singleLine(event.title) || "Task dispatched";
+    return `[${timestamp}] ${from} dispatched: ${summary}`;
+  }
+  if (event.intent === "task.help_needed") {
+    const question = singleLine(event.question) || "Asked for help";
+    const reason = singleLine(event.blockedReason);
+    return `[${timestamp}] ${from} asked for help: ${question}${reason ? ` (reason: ${reason})` : ""}`;
+  }
+  if (event.intent === "task.result") {
+    const output = singleLine(event.output) || singleLine(event.bodyText) || "Sent a result";
+    return `[${timestamp}] ${from} replied: ${output}`;
+  }
+  if (event.intent === "task.cancel") {
+    const body = singleLine(event.bodyText) || "Cancelled the task";
+    return `[${timestamp}] ${from} cancelled the task: ${body}`;
+  }
+  if (event.intent === "task.ack") {
+    return `[${timestamp}] ${from} acknowledged the task`;
+  }
+  return `[${timestamp}] ${from}: ${singleLine(event.bodyText) || event.intent}`;
+}
+function renderThreadHistoryForAgent(events, options = {}) {
+  const filtered = events.filter((event) => event.intent !== "task.stream.opened");
+  if (filtered.length === 0)
+    return "";
+  const maxEvents = Math.max(1, options.maxEvents ?? 8);
+  const visible = filtered.slice(-maxEvents);
+  const omitted = filtered.length - visible.length;
+  return [
+    "Prior thread context:",
+    ...omitted > 0 ? [`(${omitted} earlier event(s) omitted)`] : [],
+    ...visible.map((event) => `- ${renderEventLine(event)}`)
+  ].join("\n");
+}
+
+// ../sdk/src/client.js
 var AampClient = class _AampClient extends TinyEmitter {
   jmapClient;
   smtpSender;
   config;
+  streamAppendQueues = /* @__PURE__ */ new Map();
   constructor(config) {
     super();
     this.config = config;
@@ -1521,6 +1886,9 @@ var AampClient = class _AampClient extends TinyEmitter {
     this.jmapClient.on("task.ack", (ack) => {
       this.emit("task.ack", ack);
     });
+    this.jmapClient.on("task.stream.opened", (stream) => {
+      this.emit("task.stream.opened", stream);
+    });
     this.jmapClient.on("card.query", (query) => {
       this.emit("card.query", query);
     });
@@ -1679,6 +2047,9 @@ var AampClient = class _AampClient extends TinyEmitter {
   async sendHelp(opts) {
     return this.smtpSender.sendHelp(opts);
   }
+  async sendStreamOpened(opts) {
+    return this.smtpSender.sendStreamOpened(opts);
+  }
   async sendCardQuery(opts) {
     return this.smtpSender.sendCardQuery(opts);
   }
@@ -1740,6 +2111,293 @@ var AampClient = class _AampClient extends TinyEmitter {
     const data = await res.json();
     return data.agents;
   }
+  async getThreadHistory(taskId, opts = {}) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.mailbox.thread",
+      authToken: mailboxToken,
+      query: {
+        taskId,
+        includeStreamOpened: opts.includeStreamOpened
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Thread history fetch failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return {
+      taskId: data.taskId,
+      events: Array.isArray(data.events) ? data.events : []
+    };
+  }
+  async hydrateTaskDispatch(task) {
+    const history = await this.getThreadHistory(task.taskId);
+    const priorEvents = history.events.filter((event) => event.messageId !== task.messageId);
+    return {
+      ...task,
+      threadHistory: priorEvents,
+      threadContextText: renderThreadHistoryForAgent(priorEvents)
+    };
+  }
+  async resolveStreamCapability() {
+    const discovery = await _AampClient.discoverAampService(this.config.baseUrl);
+    const stream = discovery.capabilities?.stream;
+    if (!stream?.transport) {
+      throw new Error("AAMP stream capability is not available on this service");
+    }
+    return stream;
+  }
+  async createStream(opts) {
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.createAction ?? "aamp.stream.create",
+      method: "POST",
+      authToken: this.config.mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream create failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  getStreamAppendQueue(streamId) {
+    let queue = this.streamAppendQueues.get(streamId);
+    if (!queue) {
+      queue = { running: false, operations: [] };
+      this.streamAppendQueues.set(streamId, queue);
+    }
+    return queue;
+  }
+  async dispatchStreamAppend(opts) {
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.appendAction ?? "aamp.stream.append",
+      method: "POST",
+      authToken: this.config.mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream append failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  enqueueStreamAppend(streamId, operation) {
+    const queue = this.getStreamAppendQueue(streamId);
+    queue.operations.push(operation);
+    void this.drainStreamAppendQueue(streamId);
+  }
+  async drainStreamAppendQueue(streamId) {
+    const queue = this.streamAppendQueues.get(streamId);
+    if (!queue || queue.running)
+      return;
+    queue.running = true;
+    try {
+      while (queue.operations.length) {
+        const operation = queue.operations.shift();
+        if (!operation)
+          continue;
+        if (operation.kind === "text-delta-batch") {
+          try {
+            const event = await this.dispatchStreamAppend({
+              streamId,
+              type: "text.delta",
+              payload: {
+                ...operation.payload,
+                text: operation.text
+              }
+            });
+            for (const resolve of operation.resolvers)
+              resolve(event);
+          } catch (error) {
+            for (const reject of operation.rejecters)
+              reject(error);
+          }
+          continue;
+        }
+        try {
+          const event = await this.dispatchStreamAppend(operation.opts);
+          operation.resolve(event);
+        } catch (error) {
+          operation.reject(error);
+        }
+      }
+    } finally {
+      queue.running = false;
+      if (queue.operations.length === 0) {
+        this.streamAppendQueues.delete(streamId);
+      }
+    }
+  }
+  async flushStreamAppendQueue(streamId) {
+    while (true) {
+      const queue = this.streamAppendQueues.get(streamId);
+      if (!queue)
+        return;
+      if (!queue.running && queue.operations.length === 0) {
+        this.streamAppendQueues.delete(streamId);
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  async appendStreamEvent(opts) {
+    if (opts.type === "text.delta" && typeof opts.payload.text === "string") {
+      return await new Promise((resolve, reject) => {
+        const queue = this.getStreamAppendQueue(opts.streamId);
+        const lastOperation = queue.operations.at(-1);
+        if (lastOperation?.kind === "text-delta-batch") {
+          lastOperation.text += String(opts.payload.text ?? "");
+          lastOperation.resolvers.push(resolve);
+          lastOperation.rejecters.push(reject);
+          return;
+        }
+        this.enqueueStreamAppend(opts.streamId, {
+          kind: "text-delta-batch",
+          text: String(opts.payload.text ?? ""),
+          payload: {
+            ...opts.payload
+          },
+          resolvers: [resolve],
+          rejecters: [reject]
+        });
+      });
+    }
+    return await new Promise((resolve, reject) => {
+      this.enqueueStreamAppend(opts.streamId, {
+        kind: "single-event",
+        opts,
+        resolve,
+        reject
+      });
+    });
+  }
+  async closeStream(opts) {
+    await this.flushStreamAppendQueue(opts.streamId);
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.closeAction ?? "aamp.stream.close",
+      method: "POST",
+      authToken: this.config.mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream close failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  async getTaskStream(opts) {
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.getAction ?? "aamp.stream.get",
+      authToken: this.config.mailboxToken,
+      query: {
+        ...opts.taskId ? { taskId: opts.taskId } : {},
+        ...opts.streamId ? { streamId: opts.streamId } : {}
+      }
+    });
+    if (res.status === 404)
+      return null;
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream get failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  async subscribeStream(streamId, handlers, opts = {}) {
+    const stream = await this.resolveStreamCapability();
+    const template = stream.subscribeUrlTemplate;
+    if (!template)
+      throw new Error("AAMP stream subscribeUrlTemplate is missing");
+    const url = new URL(template.replace("{streamId}", encodeURIComponent(streamId)), this.config.baseUrl);
+    if (opts.lastEventId) {
+      url.searchParams.set("lastEventId", opts.lastEventId);
+    }
+    const controller = new AbortController();
+    if (opts.signal) {
+      opts.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    const res = await fetch(url, {
+      headers: {
+        Authorization: `Basic ${this.config.mailboxToken}`,
+        Accept: "text/event-stream"
+      },
+      signal: controller.signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`AAMP stream subscribe failed: ${res.status} ${res.statusText}`);
+    }
+    handlers.onOpen?.();
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = "message";
+    let currentId = "";
+    let currentData = [];
+    const flush = () => {
+      if (!currentData.length)
+        return;
+      try {
+        const parsed = JSON.parse(currentData.join("\n"));
+        handlers.onEvent({
+          ...parsed,
+          ...currentId ? { id: currentId } : {},
+          type: parsed.type ?? currentEvent
+        });
+      } catch (err) {
+        handlers.onError?.(err);
+      } finally {
+        currentEvent = "message";
+        currentId = "";
+        currentData = [];
+      }
+    };
+    void (async () => {
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          let index = buffer.indexOf("\n\n");
+          while (index >= 0) {
+            const frame = buffer.slice(0, index);
+            buffer = buffer.slice(index + 2);
+            for (const rawLine of frame.split("\n")) {
+              const line = rawLine.replace(/\r$/, "");
+              if (!line || line.startsWith(":"))
+                continue;
+              if (line.startsWith("event:")) {
+                currentEvent = line.slice(6).trim();
+              } else if (line.startsWith("id:")) {
+                currentId = line.slice(3).trim();
+              } else if (line.startsWith("data:")) {
+                currentData.push(line.slice(5).trimStart());
+              }
+            }
+            flush();
+            index = buffer.indexOf("\n\n");
+          }
+        }
+      } catch (err) {
+        if (!controller.signal.aborted) {
+          handlers.onError?.(err);
+        }
+      } finally {
+        buffer += decoder.decode();
+        controller.abort();
+      }
+    })();
+    return {
+      close() {
+        controller.abort();
+      }
+    };
+  }
   /**
    * Download a blob (attachment) by its JMAP blobId.
    * Use this to retrieve attachment content from received TaskDispatch or TaskResult messages.
@@ -1767,6 +2425,9 @@ var AampClient = class _AampClient extends TinyEmitter {
   }
 };
 
+// src/index.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+
 // src/file-store.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -1873,7 +2534,9 @@ function baseUrl(aampHost) {
   return `https://${aampHost}`;
 }
 var pendingTasks = /* @__PURE__ */ new Map();
+var activeTaskStreams = /* @__PURE__ */ new Map();
 var terminalTaskIds = new Set(loadTaskState(defaultTaskStatePath()).terminalTaskIds ?? []);
+var AAMP_SESSION_PREFIX = "aamp:";
 var dispatchedSubtasks = /* @__PURE__ */ new Map();
 var waitingDispatches = /* @__PURE__ */ new Map();
 var aampClient = null;
@@ -1884,9 +2547,57 @@ var lastTransportMode = "disconnected";
 var lastLoggedTransportMode = "disconnected";
 var reconcileTimer = null;
 var transportMonitorTimer = null;
-var currentSessionKey = "agent:main:main";
+var historicalReconcileCompleted = false;
 var channelRuntime = null;
 var channelCfg = null;
+async function ensureTaskStream(task) {
+  if (!aampClient?.isConnected())
+    return null;
+  const existing = activeTaskStreams.get(task.taskId);
+  if (existing)
+    return existing;
+  const created = await aampClient.createStream({
+    taskId: task.taskId,
+    peerEmail: task.from
+  });
+  await aampClient.sendStreamOpened({
+    to: task.from,
+    taskId: task.taskId,
+    streamId: created.streamId,
+    inReplyTo: task.messageId || void 0
+  });
+  await aampClient.appendStreamEvent({
+    streamId: created.streamId,
+    type: "status",
+    payload: { state: "running", label: "Task queued in OpenClaw" }
+  });
+  activeTaskStreams.set(task.taskId, created.streamId);
+  return created.streamId;
+}
+async function appendTaskStream(taskId, type, payload) {
+  if (!aampClient?.isConnected())
+    return;
+  const streamId = activeTaskStreams.get(taskId);
+  if (!streamId)
+    return;
+  await aampClient.appendStreamEvent({
+    streamId,
+    type,
+    payload
+  });
+}
+async function closeTaskStream(taskId, payload) {
+  if (!aampClient?.isConnected())
+    return;
+  const streamId = activeTaskStreams.get(taskId);
+  if (!streamId)
+    return;
+  activeTaskStreams.delete(taskId);
+  await aampClient.closeStream({
+    streamId,
+    payload
+  });
+}
 function logTransportState(api, mode, email, previousMode) {
   if (mode === previousMode)
     return;
@@ -1903,6 +2614,12 @@ function logTransportState(api, mode, email, previousMode) {
 function isSyntheticPendingKey(taskKey) {
   return taskKey.startsWith("result:") || taskKey.startsWith("help:");
 }
+function isAampSessionKey(sessionKey) {
+  return typeof sessionKey === "string" && sessionKey.startsWith(AAMP_SESSION_PREFIX);
+}
+function buildAampWakeSessionKey(kind, id) {
+  return `${AAMP_SESSION_PREFIX}wake:${kind}:${id}`;
+}
 function saveTerminalTaskIds() {
   saveTaskState({ terminalTaskIds: [...terminalTaskIds] }, defaultTaskStatePath());
 }
@@ -1928,6 +2645,17 @@ function hasExpired(task) {
   }
   return false;
 }
+function isTransientTransportError(message) {
+  return [
+    "ECONNRESET",
+    "ETIMEDOUT",
+    "ECONNREFUSED",
+    "EPIPE",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "fetch failed"
+  ].some((needle) => message.includes(needle));
+}
 function nextPendingEntry() {
   const entries = [...pendingTasks.entries()];
   const notifications = entries.filter(([key]) => key.startsWith("result:") || key.startsWith("help:"));
@@ -1950,6 +2678,8 @@ function queuePendingTask(task) {
     from: task.from,
     title: task.title,
     bodyText: task.bodyText ?? "",
+    threadHistory: task.threadHistory ?? [],
+    threadContextText: task.threadContextText ?? "",
     priority: task.priority ?? "normal",
     ...task.expiresAt ? { expiresAt: task.expiresAt } : {},
     contextLinks: task.contextLinks ?? [],
@@ -2023,6 +2753,18 @@ var src_default = {
         default: "openclaw-agent",
         description: "Agent name prefix used in the mailbox address"
       },
+      summary: {
+        type: "string",
+        description: "Directory summary shown when other agents search for this agent."
+      },
+      cardText: {
+        type: "string",
+        description: "Inline card text used for automatic card.response replies."
+      },
+      cardFile: {
+        type: "string",
+        description: "Absolute path to a card text file. Used when cardText is not set."
+      },
       credentialsFile: {
         type: "string",
         description: "Absolute path to cache AAMP credentials between gateway restarts. Default: ~/.openclaw/extensions/aamp-openclaw-plugin/.credentials.json. Delete this file to force re-registration with a new mailbox."
@@ -2089,11 +2831,35 @@ var src_default = {
         api.logger.warn(`[AAMP] Could not trigger heartbeat for ${label}: ${err.message}`);
       }
     }
+    function getConfiguredCardText() {
+      const inline = cfg.cardText?.trim();
+      if (inline)
+        return inline;
+      const file = cfg.cardFile?.trim();
+      if (!file)
+        return void 0;
+      const fromFile = readFileSync2(file, "utf-8").trim();
+      return fromFile || void 0;
+    }
+    async function syncDirectoryProfile() {
+      if (!aampClient)
+        return;
+      const summary = cfg.summary?.trim();
+      const cardText = getConfiguredCardText();
+      if (!summary && !cardText)
+        return;
+      await aampClient.updateDirectoryProfile({
+        ...summary ? { summary } : {},
+        ...cardText ? { cardText } : {}
+      });
+      api.logger.info(`[AAMP] Directory profile synced${cardText ? " (card text registered)" : ""}`);
+    }
     function wakeAgentForPendingTask(task) {
-      const fallback = () => triggerHeartbeatWake(currentSessionKey, `task ${task.taskId}`);
+      const fallbackSessionKey = buildAampWakeSessionKey("task", task.taskId);
+      const fallback = () => triggerHeartbeatWake(fallbackSessionKey, `task ${task.taskId}`);
       const dispatcher = channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher;
       api.logger.info(
-        `[AAMP] Wake requested for task ${task.taskId} \u2014 channelRuntime=${channelRuntime ? "yes" : "no"} channelCfg=${channelCfg ? "yes" : "no"} dispatcher=${typeof dispatcher === "function" ? "yes" : "no"} session=${currentSessionKey}`
+        `[AAMP] Wake requested for task ${task.taskId} \u2014 channelRuntime=${channelRuntime ? "yes" : "no"} channelCfg=${channelCfg ? "yes" : "no"} dispatcher=${typeof dispatcher === "function" ? "yes" : "no"} fallbackSession=${fallbackSessionKey}`
       );
       if (!channelRuntime || !channelCfg || typeof dispatcher !== "function") {
         fallback();
@@ -2145,6 +2911,16 @@ var src_default = {
         fallback();
       }
     }
+    async function reconcileMailbox(includeHistorical) {
+      if (!aampClient)
+        return;
+      const opts = includeHistorical ? { includeHistorical: true } : void 0;
+      const count = await aampClient.reconcileRecentEmails(100, opts);
+      if (includeHistorical && !historicalReconcileCompleted) {
+        historicalReconcileCompleted = true;
+        api.logger.info(`[AAMP] Historical mailbox reconcile complete (${count} email(s) scanned)`);
+      }
+    }
     async function doConnect(identity) {
       if (reconcileTimer) {
         clearInterval(reconcileTimer);
@@ -2171,36 +2947,49 @@ 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}`);
-            void aampClient.sendResult({
-              to: task.from,
-              taskId: task.taskId,
-              status: "rejected",
-              output: "",
-              errorMsg: decision.reason ?? `Sender ${task.from} is not allowed.`
-            }).catch((err) => {
-              api.logger.error(`[AAMP] Failed to send rejection for task ${task.taskId}: ${err.message}`);
+        void (async () => {
+          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}`);
+              void aampClient.sendResult({
+                to: task.from,
+                taskId: task.taskId,
+                status: "rejected",
+                output: "",
+                errorMsg: decision.reason ?? `Sender ${task.from} is not allowed.`
+              }).catch((err) => {
+                api.logger.error(`[AAMP] Failed to send rejection for task ${task.taskId}: ${err.message}`);
+              });
+              return;
+            }
+            const hydratedTask = await aampClient.hydrateTaskDispatch(task).catch((err) => {
+              api.logger.warn(`[AAMP] Failed to load thread history for ${task.taskId}: ${err.message}`);
+              return {
+                ...task,
+                threadHistory: [],
+                threadContextText: ""
+              };
             });
-            return;
-          }
-          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}`);
-          if (pendingTasks.has(task.taskId)) {
-            triggerHeartbeatWake(currentSessionKey, `task ${task.taskId}`);
+            if (!queuePendingTask(hydratedTask)) {
+              api.logger.info(`[AAMP] Ignoring already-terminal or expired task ${task.taskId}`);
+              return;
+            }
+            void ensureTaskStream(pendingTasks.get(task.taskId)).catch((err) => {
+              api.logger.warn(`[AAMP] Failed to open stream for task ${task.taskId}: ${err.message}`);
+            });
+            wakeAgentForPendingTask(pendingTasks.get(task.taskId));
+          } catch (err) {
+            api.logger.error(`[AAMP] task.dispatch handler failed for ${task.taskId}: ${err.message}`);
+            if (pendingTasks.has(task.taskId)) {
+              triggerHeartbeatWake(buildAampWakeSessionKey("task", task.taskId), `task ${task.taskId}`);
+            }
           }
-        }
+        })();
       });
       aampClient.on("task.cancel", (cancel) => {
         api.logger.info(`[AAMP] \u2190 task.cancel  ${cancel.taskId}  from=${cancel.from}`);
@@ -2210,6 +2999,8 @@ var src_default = {
         dispatchedSubtasks.delete(cancel.taskId);
         waitingDispatches.delete(cancel.taskId);
         rememberTerminalTask(cancel.taskId);
+        void closeTaskStream(cancel.taskId, { reason: "task.cancel" }).catch(() => {
+        });
         if (removed) {
           api.logger.info(`[AAMP] Cancelled task ${cancel.taskId} \u2014 removed from pending queue`);
         }
@@ -2330,7 +3121,7 @@ ${notifyBody?.bodyText ?? "Sub-task completed."}${actionSection}`;
               api.logger.error(`[AAMP] Channel dispatch failed: ${err.message}`);
             });
           } else {
-            const notifySessionKey = `agent:main:aamp-notify-${Date.now()}`;
+            const notifySessionKey = buildAampWakeSessionKey("result", result.taskId);
             try {
               api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: notifySessionKey });
               api.logger.info(`[AAMP] Heartbeat for sub-task result ${result.taskId}`);
@@ -2406,7 +3197,7 @@ ${notifyBody?.bodyText ?? help.question}`;
             api.logger.error(`[AAMP] Channel dispatch failed for help: ${err.message}`);
           });
         } else {
-          const helpSessionKey = `agent:main:aamp-notify-${Date.now()}`;
+          const helpSessionKey = buildAampWakeSessionKey("help", help.taskId);
           try {
             api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: helpSessionKey });
             api.logger.info(`[AAMP] Heartbeat fallback for sub-task help ${help.taskId}`);
@@ -2441,9 +3232,16 @@ ${notifyBody?.bodyText ?? help.question}`;
           }
           return;
         }
+        if (err.message.startsWith("Safety reconcile failed:") && isTransientTransportError(err.message)) {
+          api.logger.warn(`[AAMP] ${err.message}`);
+          return;
+        }
         api.logger.error(`[AAMP] ${err.message}`);
       });
       await aampClient.connect();
+      await syncDirectoryProfile().catch((err) => {
+        api.logger.warn(`[AAMP] Directory profile sync failed: ${err.message}`);
+      });
       api.logger.info(
         `[AAMP] Transport after connect \u2014 ${aampClient.isUsingPollingFallback() ? "polling fallback" : "websocket"} as ${agentEmail}`
       );
@@ -2466,9 +3264,13 @@ ${notifyBody?.bodyText ?? help.question}`;
         lastTransportMode = mode;
         lastLoggedTransportMode = mode;
       }, 1e3);
-      void aampClient.reconcileRecentEmails(100, { includeHistorical: true }).catch((err) => {
+      void reconcileMailbox(!historicalReconcileCompleted).catch((err) => {
         lastConnectionError = err.message;
-        api.logger.warn(`[AAMP] Startup mailbox reconcile failed: ${err.message}`);
+        if (!historicalReconcileCompleted) {
+          api.logger.warn(`[AAMP] Startup mailbox reconcile failed: ${err.message} (will retry historical tasks)`);
+        } else {
+          api.logger.warn(`[AAMP] Startup mailbox reconcile failed: ${err.message}`);
+        }
       });
       transportMonitorTimer = setInterval(() => {
         if (!aampClient)
@@ -2487,9 +3289,14 @@ ${notifyBody?.bodyText ?? help.question}`;
       reconcileTimer = setInterval(() => {
         if (!aampClient)
           return;
-        void aampClient.reconcileRecentEmails(100).catch((err) => {
+        const includeHistorical = !historicalReconcileCompleted;
+        void reconcileMailbox(includeHistorical).catch((err) => {
           lastConnectionError = err.message;
-          api.logger.warn(`[AAMP] Mailbox reconcile failed: ${err.message}`);
+          if (includeHistorical) {
+            api.logger.warn(`[AAMP] Mailbox reconcile failed while retrying historical tasks: ${err.message}`);
+          } else {
+            api.logger.warn(`[AAMP] Mailbox reconcile failed: ${err.message}`);
+          }
         });
       }, 15e3);
     }
@@ -2530,7 +3337,10 @@ ${notifyBody?.bodyText ?? help.question}`;
         return;
       api.logger.info(`[AAMP] gateway_start: re-triggering heartbeat for ${pendingTasks.size} pending task(s)`);
       try {
-        api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: currentSessionKey });
+        api.runtime.system.requestHeartbeatNow({
+          reason: "wake",
+          sessionKey: buildAampWakeSessionKey("queue", "gateway-start")
+        });
       } catch (err) {
         api.logger.warn(`[AAMP] gateway_start heartbeat failed: ${err.message}`);
       }
@@ -2538,8 +3348,8 @@ ${notifyBody?.bodyText ?? help.question}`;
     api.on(
       "before_prompt_build",
       (_event, ctx) => {
-        if (ctx?.sessionKey && !String(ctx.sessionKey).startsWith("aamp:")) {
-          currentSessionKey = ctx.sessionKey;
+        if (!isAampSessionKey(ctx?.sessionKey)) {
+          return {};
         }
         for (const [id, t] of pendingTasks) {
           if (hasExpired(t)) {
@@ -2642,10 +3452,12 @@ ${task.bodyText}` : "",
           `### Sub-task dispatch rules:`,
           `If you delegate work to another agent via aamp_dispatch_task, you MUST pass`,
           `parentTaskId: "${task.taskId}" to establish the parent-child relationship.`,
+          `If you need to find a suitable agent first, call aamp_directory_search.`,
           ``,
           `Task ID:  ${task.taskId}`,
           `From:     ${task.from}`,
           `Title:    ${task.title}`,
+          task.threadContextText ? `${task.threadContextText}` : "",
           task.bodyText ? `Description:
 ${task.bodyText}` : "",
           task.contextLinks.length ? `Context Links:
@@ -2659,6 +3471,44 @@ ${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
       },
       { priority: 5 }
     );
+    api.registerTool({
+      name: "aamp_directory_search",
+      description: "Search the AAMP directory for agents by capability summary, card text, or email address.",
+      parameters: {
+        type: "object",
+        required: ["query"],
+        properties: {
+          query: { type: "string", description: "Capability or keyword to search for" },
+          limit: { type: "number", description: "Maximum number of matches to return (default: 10)" },
+          includeSelf: { type: "boolean", description: "Whether to include the current agent in results" }
+        }
+      },
+      execute: async (_id, params) => {
+        if (!aampClient) {
+          return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
+        }
+        const query = String(params.query ?? "").trim();
+        if (!query) {
+          return { content: [{ type: "text", text: "Error: query is required." }] };
+        }
+        const agents = await aampClient.searchDirectory({
+          query,
+          limit: Number(params.limit ?? 10),
+          includeSelf: Boolean(params.includeSelf)
+        });
+        if (!agents.length) {
+          return { content: [{ type: "text", text: `No agents matched "${query}".` }] };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: agents.map(
+              (agent, index) => `${index + 1}. ${agent.email}${agent.summary ? ` \u2014 ${agent.summary}` : ""}`
+            ).join("\n")
+          }]
+        };
+      }
+    }, { name: "aamp_directory_search" });
     api.registerTool({
       name: "aamp_send_result",
       description: "Send the result of an AAMP task back to the dispatcher. Call this after you have finished processing the task.",
@@ -2758,6 +3608,18 @@ ${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
             content: readBinaryFile(a.path)
           }));
         }
+        await appendTaskStream(task.taskId, "status", {
+          state: "completing",
+          label: `Sending ${p.status} result`
+        });
+        if (p.output) {
+          await appendTaskStream(task.taskId, "text.delta", { text: p.output });
+        }
+        await closeTaskStream(task.taskId, {
+          reason: "task.result",
+          status: p.status,
+          ...p.errorMsg ? { error: p.errorMsg } : {}
+        });
         await aampClient.sendResult({
           to: task.from,
           taskId: task.taskId,
@@ -2773,7 +3635,10 @@ ${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
         api.logger.info(`[AAMP] \u2192 task.result  ${task.taskId}  ${p.status}`);
         if (pendingTasks.size > 0) {
           try {
-            api.runtime.system.requestHeartbeatNow({ reason: "wake", sessionKey: currentSessionKey });
+            api.runtime.system.requestHeartbeatNow({
+              reason: "wake",
+              sessionKey: buildAampWakeSessionKey("queue", "follow-up")
+            });
           } catch {
           }
         }
@@ -2824,6 +3689,13 @@ ${task.contextLinks.map((l) => `  - ${l}`).join("\n")}` : "",
         if (!aampClient?.isConnected()) {
           return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
         }
+        await appendTaskStream(task.taskId, "status", {
+          state: "help_needed",
+          label: p.blockedReason
+        });
+        await closeTaskStream(task.taskId, {
+          reason: "task.help_needed"
+        });
         await aampClient.sendHelp({
           to: task.from,
           taskId: task.taskId,