@awebai/claude-channel 1.4.10 → 1.4.11

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aweb-channel",
   "description": "aweb agent coordination channel: receive mail, chat, tasks, and control signals from your agent team in real time.",
-  "version": "1.4.10",
+  "version": "1.4.11",
   "author": {
     "name": "awebai"
   },

package/dist/index.js

@@ -21260,10 +21260,7 @@ var StdioServerTransport = class {
 };
 
 // src/index.ts
-import { join as join3 } from "node:path";
-import { homedir as homedir2 } from "node:os";
 import { realpathSync } from "node:fs";
-import { readFile as readFile4 } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 // ../channel-core/dist/api/client.js
@@ -26694,97 +26691,114 @@ function escapeJSON3(s) {
   return result;
 }
 
+// ../channel-core/dist/local_aw.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+function createLocalAWDecryptProvider(options) {
+  const awCommand = options.awCommand || process.env.AW_BIN || "aw";
+  return {
+    async mailMessage(messageID) {
+      const id = messageID.trim();
+      if (!id)
+        return null;
+      const { stdout } = await execFileAsync(awCommand, ["mail", "show", "--message-id", id, "--json"], { cwd: options.workdir, timeout: 15e3, maxBuffer: 1024 * 1024 });
+      const payload = parseJSONOutput(stdout);
+      return (payload.messages || []).find((msg) => msg.message_id === id) || null;
+    },
+    async chatMessage(sessionID, messageID) {
+      const session = sessionID.trim();
+      const id = messageID.trim();
+      if (!session || !id)
+        return null;
+      const { stdout } = await execFileAsync(awCommand, ["chat", "history", "--session-id", session, "--message-id", id, "--limit", "1", "--json"], { cwd: options.workdir, timeout: 15e3, maxBuffer: 1024 * 1024 });
+      const payload = parseJSONOutput(stdout);
+      return (payload.messages || []).find((msg) => msg.message_id === id) || null;
+    }
+  };
+}
+function parseJSONOutput(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed)
+    throw new Error("aw returned empty JSON output");
+  const start = trimmed.indexOf("{");
+  if (start < 0)
+    throw new Error("aw JSON output did not contain an object");
+  return JSON.parse(trimmed.slice(start));
+}
+
 // ../channel-core/dist/channel.js
 import { dirname as dirname2, join as join2 } from "node:path";
 import { homedir } from "node:os";
+import { mkdir as mkdir2, readFile as readFile4, writeFile } from "node:fs/promises";
 var DEFAULT_PIN_STORE_PATH = join2(homedir(), ".config", "aw", "known_agents.yaml");
 var DEFAULT_DELIVERY_STORE_PATH = join2(homedir(), ".config", "aw", "channel-delivered-ids.json");
-var DELIVERED_IDS_TTL_MS = 24 * 60 * 60 * 1e3;
-
-// src/index.ts
-var PIN_STORE_PATH = join3(homedir2(), ".config", "aw", "known_agents.yaml");
 var MAX_DISPATCHED_IDS = 2e3;
+var MAX_DELIVERED_IDS = 5e3;
+var DELIVERED_IDS_TTL_MS = 24 * 60 * 60 * 1e3;
 var MAIL_FETCH_LIMIT = 200;
 var CHAT_FETCH_LIMIT = 2e3;
-async function loadPinStore2() {
+async function loadPinStore(path = DEFAULT_PIN_STORE_PATH) {
   try {
-    const content = await readFile4(PIN_STORE_PATH, "utf-8");
+    const content = await readFile4(path, "utf-8");
     return PinStore.fromYAML(content);
   } catch {
     return new PinStore();
   }
 }
-function pruneDispatched(dispatched) {
-  if (dispatched.size <= MAX_DISPATCHED_IDS) return;
-  const excess = dispatched.size - MAX_DISPATCHED_IDS;
-  let removed = 0;
-  for (const id of dispatched) {
-    if (removed >= excess) break;
-    dispatched.delete(id);
-    removed++;
+var DeliveryStore = class _DeliveryStore {
+  path;
+  entries;
+  constructor(path, entries) {
+    this.path = path;
+    this.entries = entries;
   }
-}
-function dispatchKey(channel, conversationID, messageID) {
-  const conversation = (conversationID || "").trim();
-  return `${channel}:${conversation}:${messageID}`;
-}
-async function main() {
-  const workdir = process.cwd();
-  const config2 = await resolveConfig(workdir);
-  const client = new APIClient(config2.baseURL, {
-    did: config2.did,
-    stableID: config2.stableID,
-    signingKey: config2.signingKey,
-    teamID: config2.teamID,
-    teamCertificateHeader: config2.teamCertificateHeader
-  });
-  const pinStore = await loadPinStore2();
-  const registry2 = new RegistryResolver(fetch, void 0, void 0, {
-    fallbackRegistryURL: resolveRegistryFallbackURL2(config2.registryURL)
-  });
-  const trust = new SenderTrustManager(
-    client,
-    registry2,
-    config2.teamID,
-    config2.did,
-    config2.stableID
-  );
-  const mcp = new Server(
-    { name: "aweb", version: "0.1.0" },
-    {
-      capabilities: {
-        experimental: { "claude/channel": {} }
-      },
-      instructions: `Events from the aweb channel are coordination messages from other agents in your team. Use the aw CLI to respond, not MCP tools.
-
-Mail events (type="mail") are async. Read them and act if needed. Confirmed channel delivery marks the source message handled so reconnects do not replay stale mail. Reply with: aw mail reply <message_id> --body "<reply>".
-
-Chat events (type="chat") may have sender_waiting="true", meaning the sender is blocked waiting for your reply. Respond promptly with: aw chat send-and-wait <from> "<reply>"
-If you need more time, send a status update the same way.
-
-Control events (type="control") are operational signals. On "pause", stop current work and wait. On "resume", continue. On "interrupt", stop and await new instructions.`
+  static async load(path = DEFAULT_DELIVERY_STORE_PATH) {
+    try {
+      const raw = JSON.parse(await readFile4(path, "utf-8"));
+      const now = Date.now();
+      const entries = /* @__PURE__ */ new Map();
+      for (const [key, value] of Object.entries(raw)) {
+        const timestamp2 = typeof value === "number" ? value : Date.parse(value);
+        if (Number.isFinite(timestamp2) && now - timestamp2 <= DELIVERED_IDS_TTL_MS) {
+          entries.set(key, timestamp2);
+        }
+      }
+      return new _DeliveryStore(path, entries);
+    } catch {
+      return new _DeliveryStore(path, /* @__PURE__ */ new Map());
     }
-  );
-  const transport = new StdioServerTransport();
-  await mcp.connect(transport);
-  const abort = new AbortController();
-  process.on("SIGINT", () => abort.abort());
-  process.on("SIGTERM", () => abort.abort());
-  await startEventLoop(
-    mcp,
-    client,
-    pinStore,
-    trust,
-    {
-      alias: config2.alias,
-      address: config2.address,
-      did: config2.did,
-      stableID: config2.stableID
-    },
-    abort.signal
-  );
-}
-function resolveRegistryFallbackURL2(identityRegistryURL = "") {
+  }
+  has(key) {
+    this.prune();
+    return this.entries.has(key);
+  }
+  mark(key) {
+    this.entries.set(key, Date.now());
+    this.prune();
+  }
+  async save() {
+    this.prune();
+    await mkdir2(dirname2(this.path), { recursive: true });
+    const payload = Object.fromEntries([...this.entries.entries()].map(([key, value]) => [key, new Date(value).toISOString()]));
+    await writeFile(this.path, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+  }
+  prune() {
+    const now = Date.now();
+    for (const [key, value] of this.entries) {
+      if (now - value > DELIVERED_IDS_TTL_MS)
+        this.entries.delete(key);
+    }
+    if (this.entries.size <= MAX_DELIVERED_IDS)
+      return;
+    const sorted = [...this.entries.entries()].sort((a, b) => a[1] - b[1]);
+    for (const [key] of sorted.slice(0, this.entries.size - MAX_DELIVERED_IDS)) {
+      this.entries.delete(key);
+    }
+  }
+};
+function resolveRegistryFallbackURL(identityRegistryURL = "") {
   const envRegistryURL = (process.env.AWID_REGISTRY_URL || "").trim();
   if (envRegistryURL) {
     if (envRegistryURL.toLowerCase() === "local") {
@@ -26795,183 +26809,299 @@ function resolveRegistryFallbackURL2(identityRegistryURL = "") {
   const configuredRegistryURL = identityRegistryURL.trim();
   return configuredRegistryURL || void 0;
 }
-async function startEventLoop(mcp, client, pinStore, trust, self, signal) {
+function createRegistryResolver(registryURL = "") {
+  return new RegistryResolver(fetch, void 0, void 0, {
+    fallbackRegistryURL: resolveRegistryFallbackURL(registryURL)
+  });
+}
+function createChannelClient(config2) {
+  return new APIClient(config2.baseURL, {
+    did: config2.did,
+    stableID: config2.stableID,
+    signingKey: config2.signingKey,
+    teamID: config2.teamID,
+    teamCertificateHeader: config2.teamCertificateHeader
+  });
+}
+async function startChannelLoop(options) {
   const dispatched = /* @__PURE__ */ new Set();
-  for await (const event of streamAgentEvents(client, signal)) {
+  const deliveryStore = options.deliveryStore || await DeliveryStore.load(DEFAULT_DELIVERY_STORE_PATH);
+  const localDecrypt = options.localDecrypt || (options.workdir ? createLocalAWDecryptProvider({ workdir: options.workdir, awCommand: options.awCommand }) : void 0);
+  const log = options.log || (() => {
+  });
+  for await (const event of streamAgentEvents(options.client, options.signal)) {
     try {
-      await dispatchEvent(mcp, client, pinStore, trust, self, dispatched, event);
+      await dispatchAgentEvent({ ...options, deliveryStore, localDecrypt }, dispatched, event);
       pruneDispatched(dispatched);
     } catch (err2) {
-      console.error(`[aw-channel] dispatch error: ${err2}`);
+      log(`[aw-channel] dispatch error: ${err2}`);
     }
   }
 }
-async function dispatchEvent(mcp, client, pinStore, trust, self, dispatched, event) {
+async function dispatchAgentEvent(options, dispatched, event) {
   switch (event.type) {
-    case "mail_message": {
-      const messages = await fetchInbox(client, true, MAIL_FETCH_LIMIT, event.message_id);
-      let pinsDirty = false;
-      for (const msg of messages) {
-        if (isSelfSender(msg.from_alias, msg.from_address, msg.from_stable_id, msg.from_did, self)) continue;
-        const conversationID = msg.conversation_id || event.conversation_id;
-        const key = dispatchKey("mail", conversationID, msg.message_id);
-        if (dispatched.has(key)) {
-          if (!msg.read_at) await ackMessage(client, msg.message_id);
-          continue;
-        }
-        dispatched.add(key);
-        const from = senderDisplayAddress(msg.from_alias, msg.from_address);
-        const tofu = await trust.normalizeTrust(
-          pinStore,
-          msg.verification_status,
-          senderTrustAddress(msg.from_alias, msg.from_address),
-          msg.from_did,
-          msg.from_stable_id,
-          msg.to_did,
-          msg.to_stable_id,
-          msg.rotation_announcement,
-          msg.replacement_announcement,
-          msg.signed_from || msg.from_address || msg.from_alias || ""
-        );
-        msg.verification_status = tofu.status;
-        if (tofu.stored) pinsDirty = true;
-        const meta3 = {
-          type: "mail",
-          from,
-          message_id: msg.message_id
-        };
-        if (conversationID) meta3.conversation_id = conversationID;
-        if (msg.subject) meta3.subject = msg.subject;
-        if (msg.priority && msg.priority !== "normal") meta3.priority = msg.priority;
-        if (msg.verification_status) meta3.verified = String(msg.verification_status === "verified" || msg.verification_status === "verified_custodial");
-        await mcp.notification({
-          method: "notifications/claude/channel",
-          params: { content: msg.body, meta: meta3 }
-        });
-        await ackMessage(client, msg.message_id);
-      }
-      if (pinsDirty) await pinStore.save(PIN_STORE_PATH);
+    case "mail_message":
+      await dispatchMailEvent(options, dispatched, event);
       break;
-    }
-    case "chat_message": {
-      if (!event.session_id) break;
-      const messages = await fetchHistory(client, event.session_id, true, CHAT_FETCH_LIMIT, event.message_id);
-      let pinsDirty = false;
-      let lastMessageId;
-      for (const msg of messages) {
-        if (isSelfSender(msg.from_agent, msg.from_address, msg.from_stable_id, msg.from_did, self)) continue;
-        const conversationID = msg.conversation_id || event.conversation_id || event.session_id;
-        const key = dispatchKey("chat", conversationID, msg.message_id);
-        if (dispatched.has(key)) {
-          lastMessageId = msg.message_id;
-          continue;
-        }
-        dispatched.add(key);
-        const from = senderDisplayAddress(msg.from_agent, msg.from_address);
-        const tofu = await trust.normalizeTrust(
-          pinStore,
-          msg.verification_status,
-          senderTrustAddress(msg.from_agent, msg.from_address),
-          msg.from_did,
-          msg.from_stable_id,
-          msg.to_did,
-          msg.to_stable_id,
-          msg.rotation_announcement,
-          msg.replacement_announcement,
-          msg.signed_from || msg.from_address || msg.from_agent || ""
-        );
-        msg.verification_status = tofu.status;
-        if (tofu.stored) pinsDirty = true;
-        const meta3 = {
-          type: "chat",
-          from,
-          session_id: event.session_id,
-          message_id: msg.message_id
-        };
-        if (conversationID) meta3.conversation_id = conversationID;
-        if (event.sender_waiting) meta3.sender_waiting = "true";
-        if (msg.sender_leaving) meta3.sender_leaving = "true";
-        if (msg.verification_status) meta3.verified = String(msg.verification_status === "verified" || msg.verification_status === "verified_custodial");
-        await mcp.notification({
-          method: "notifications/claude/channel",
-          params: { content: msg.body, meta: meta3 }
-        });
-        lastMessageId = msg.message_id;
-      }
-      if (lastMessageId) await markRead(client, event.session_id, lastMessageId);
-      if (pinsDirty) await pinStore.save(PIN_STORE_PATH);
+    case "chat_message":
+      await dispatchChatEvent(options, dispatched, event);
       break;
-    }
     case "control_pause":
     case "control_resume":
-    case "control_interrupt": {
-      const signalType = event.type.replace("control_", "");
-      await mcp.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: "",
-          meta: {
-            type: "control",
-            signal: signalType,
-            signal_id: event.signal_id || ""
-          }
+    case "control_interrupt":
+      await options.onAwakening({
+        kind: "control",
+        content: "",
+        deliveryIntent: "steer",
+        meta: {
+          type: "control",
+          signal: event.type.replace("control_", ""),
+          signal_id: event.signal_id || ""
         }
       });
       break;
-    }
-    case "work_available": {
-      await mcp.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: event.title || "",
-          meta: {
-            type: "work",
-            task_id: event.task_id || ""
-          }
+    case "work_available":
+      await options.onAwakening({
+        kind: "work",
+        content: event.title || "",
+        deliveryIntent: "ambient",
+        meta: {
+          type: "work",
+          task_id: event.task_id || ""
         }
       });
       break;
-    }
-    case "claim_update": {
-      await mcp.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: event.title || "",
-          meta: {
-            type: "claim",
-            task_id: event.task_id || "",
-            title: event.title || "",
-            status: event.status || ""
-          }
+    case "claim_update":
+      await options.onAwakening({
+        kind: "claim",
+        content: event.title || "",
+        deliveryIntent: "ambient",
+        meta: {
+          type: "claim",
+          task_id: event.task_id || "",
+          title: event.title || "",
+          status: event.status || ""
         }
       });
       break;
-    }
-    case "claim_removed": {
-      await mcp.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: "",
-          meta: {
-            type: "claim_removed",
-            task_id: event.task_id || ""
-          }
+    case "claim_removed":
+      await options.onAwakening({
+        kind: "claim_removed",
+        content: "",
+        deliveryIntent: "ambient",
+        meta: {
+          type: "claim_removed",
+          task_id: event.task_id || ""
         }
       });
       break;
-    }
     default:
       break;
   }
 }
+async function dispatchMailEvent(options, dispatched, event) {
+  const messages = await fetchInbox(options.client, true, MAIL_FETCH_LIMIT, event.message_id);
+  let pinsDirty = false;
+  for (const msg of messages) {
+    if (isSelfSender(msg.from_alias, msg.from_address, msg.from_stable_id, msg.from_did, options.self))
+      continue;
+    const conversationID = msg.conversation_id || event.conversation_id;
+    const key = dispatchKey("mail", conversationID, msg.message_id);
+    if (dispatched.has(key) || options.deliveryStore?.has(key)) {
+      if (!msg.read_at)
+        await ackMessage(options.client, msg.message_id);
+      continue;
+    }
+    const from = senderDisplayAddress(msg.from_alias, msg.from_address);
+    const decrypt = await resolveMailForDelivery(options, msg);
+    if (!decrypt.ok) {
+      await options.onAwakening({
+        kind: "mail",
+        content: "",
+        meta: encryptedDeliveryFailureMeta("mail", from, msg.message_id, conversationID, decrypt.error),
+        deliveryIntent: "wake"
+      });
+      continue;
+    }
+    const trust = await normalizeMessageTrust(options, msg, msg.from_alias, msg.from_address, msg.to_did, msg.to_stable_id);
+    msg.verification_status = trust.status;
+    if (trust.stored)
+      pinsDirty = true;
+    const meta3 = {
+      type: "mail",
+      from,
+      message_id: msg.message_id,
+      trust_status: msg.verification_status || "unknown",
+      verified: String(isTrustedVerificationStatus(msg.verification_status))
+    };
+    if (conversationID)
+      meta3.conversation_id = conversationID;
+    if (msg.subject)
+      meta3.subject = msg.subject;
+    if (msg.priority && msg.priority !== "normal")
+      meta3.priority = msg.priority;
+    await options.onAwakening({
+      kind: "mail",
+      content: msg.body,
+      meta: meta3,
+      deliveryIntent: "wake"
+    });
+    dispatched.add(key);
+    if (options.deliveryStore) {
+      options.deliveryStore.mark(key);
+      await options.deliveryStore.save();
+    }
+    await ackMessage(options.client, msg.message_id);
+  }
+  if (pinsDirty)
+    await options.pinStore.save(options.pinStorePath || DEFAULT_PIN_STORE_PATH);
+}
+async function dispatchChatEvent(options, dispatched, event) {
+  if (!event.session_id)
+    return;
+  const messages = await fetchHistory(options.client, event.session_id, true, CHAT_FETCH_LIMIT, event.message_id);
+  let pinsDirty = false;
+  let lastMessageId;
+  for (const msg of messages) {
+    if (isSelfSender(msg.from_agent, msg.from_address, msg.from_stable_id, msg.from_did, options.self))
+      continue;
+    const conversationID = msg.conversation_id || event.conversation_id || event.session_id;
+    const key = dispatchKey("chat", conversationID, msg.message_id);
+    if (dispatched.has(key) || options.deliveryStore?.has(key)) {
+      lastMessageId = msg.message_id;
+      continue;
+    }
+    const from = senderDisplayAddress(msg.from_agent, msg.from_address);
+    const decrypt = await resolveChatForDelivery(options, event.session_id, msg);
+    if (!decrypt.ok) {
+      await options.onAwakening({
+        kind: "chat",
+        content: "",
+        meta: encryptedDeliveryFailureMeta("chat", from, msg.message_id, conversationID, decrypt.error, event.session_id),
+        deliveryIntent: event.sender_waiting ? "steer" : "wake"
+      });
+      continue;
+    }
+    const trust = await normalizeMessageTrust(options, msg, msg.from_agent, msg.from_address, msg.to_did, msg.to_stable_id);
+    msg.verification_status = trust.status;
+    if (trust.stored)
+      pinsDirty = true;
+    const meta3 = {
+      type: "chat",
+      from,
+      session_id: event.session_id,
+      message_id: msg.message_id,
+      trust_status: msg.verification_status || "unknown",
+      verified: String(isTrustedVerificationStatus(msg.verification_status))
+    };
+    if (conversationID)
+      meta3.conversation_id = conversationID;
+    if (event.sender_waiting)
+      meta3.sender_waiting = "true";
+    if (msg.sender_leaving)
+      meta3.sender_leaving = "true";
+    await options.onAwakening({
+      kind: "chat",
+      content: msg.body,
+      meta: meta3,
+      deliveryIntent: event.sender_waiting ? "steer" : "wake"
+    });
+    dispatched.add(key);
+    if (options.deliveryStore) {
+      options.deliveryStore.mark(key);
+      await options.deliveryStore.save();
+    }
+    lastMessageId = msg.message_id;
+  }
+  if (lastMessageId)
+    await markRead(options.client, event.session_id, lastMessageId);
+  if (pinsDirty)
+    await options.pinStore.save(options.pinStorePath || DEFAULT_PIN_STORE_PATH);
+}
+async function normalizeMessageTrust(options, msg, fromAlias, fromAddress, toDID, toStableID) {
+  return options.trust.normalizeTrust(options.pinStore, msg.verification_status, senderTrustAddress(fromAlias, fromAddress), msg.from_did, msg.from_stable_id, toDID, toStableID, msg.rotation_announcement, msg.replacement_announcement, msg.signed_from || fromAddress || fromAlias || "");
+}
+async function resolveMailForDelivery(options, msg) {
+  if (!isEncryptedMessage(msg))
+    return { ok: true };
+  if (!options.localDecrypt?.mailMessage) {
+    return { ok: false, error: "local aw decrypt provider is not configured" };
+  }
+  try {
+    const decrypted = await options.localDecrypt.mailMessage(msg.message_id);
+    if (!decrypted || typeof decrypted.body !== "string") {
+      return { ok: false, error: "local aw did not return decrypted mail body" };
+    }
+    Object.assign(msg, decrypted);
+    return { ok: true };
+  } catch (error2) {
+    return { ok: false, error: error2 instanceof Error ? error2.message : String(error2) };
+  }
+}
+async function resolveChatForDelivery(options, sessionID, msg) {
+  if (!isEncryptedMessage(msg))
+    return { ok: true };
+  if (!options.localDecrypt?.chatMessage) {
+    return { ok: false, error: "local aw decrypt provider is not configured" };
+  }
+  try {
+    const decrypted = await options.localDecrypt.chatMessage(sessionID, msg.message_id);
+    if (!decrypted || typeof decrypted.body !== "string") {
+      return { ok: false, error: "local aw did not return decrypted chat body" };
+    }
+    Object.assign(msg, decrypted);
+    return { ok: true };
+  } catch (error2) {
+    return { ok: false, error: error2 instanceof Error ? error2.message : String(error2) };
+  }
+}
+function isEncryptedMessage(msg) {
+  return msg.content_mode === "encrypted_v2" || msg.message_version === 2 || msg.encrypted_envelope !== void 0;
+}
+function encryptedDeliveryFailureMeta(type2, from, messageID, conversationID, error2, sessionID) {
+  const meta3 = {
+    type: type2,
+    from,
+    message_id: messageID,
+    encrypted: "true",
+    decrypted: "false",
+    decrypt_error: error2
+  };
+  if (conversationID)
+    meta3.conversation_id = conversationID;
+  if (sessionID)
+    meta3.session_id = sessionID;
+  return meta3;
+}
+function isTrustedVerificationStatus(status) {
+  return status === "verified" || status === "verified_custodial";
+}
+function pruneDispatched(dispatched) {
+  if (dispatched.size <= MAX_DISPATCHED_IDS)
+    return;
+  const excess = dispatched.size - MAX_DISPATCHED_IDS;
+  let removed = 0;
+  for (const id of dispatched) {
+    if (removed >= excess)
+      break;
+    dispatched.delete(id);
+    removed++;
+  }
+}
+function dispatchKey(channel, conversationID, messageID) {
+  const conversation = (conversationID || "").trim();
+  return `${channel}:${conversation}:${messageID}`;
+}
 function senderDisplayAddress(alias, address) {
   const qualified = (address || "").trim();
-  if (qualified) return qualified;
+  if (qualified)
+    return qualified;
   return (alias || "").trim();
 }
 function senderTrustAddress(alias, address) {
   const qualified = (address || "").trim();
-  if (qualified) return qualified;
+  if (qualified)
+    return qualified;
   return (alias || "").trim();
 }
 function isSelfSender(alias, address, stableID, did, self) {
@@ -26981,16 +27111,91 @@ function isSelfSender(alias, address, stableID, did, self) {
   const selfAddress = self.address.trim();
   const selfStableID = self.stableID.trim();
   const selfDID = self.did.trim();
-  if (selfAddress && msgAddress && selfAddress === msgAddress) return true;
-  if (selfStableID && (msgStableID === selfStableID || msgDID === selfStableID)) return true;
-  if (selfDID && (msgStableID === selfDID || msgDID === selfDID)) return true;
+  if (selfAddress && msgAddress && selfAddress === msgAddress)
+    return true;
+  if (selfStableID && (msgStableID === selfStableID || msgDID === selfStableID))
+    return true;
+  if (selfDID && (msgStableID === selfDID || msgDID === selfDID))
+    return true;
   if ((selfAddress || selfStableID || selfDID) && (msgAddress || msgStableID || msgDID)) {
     return false;
   }
   const selfAlias = self.alias.trim();
-  if (!selfAlias) return false;
+  if (!selfAlias)
+    return false;
   return (alias || "").trim() === selfAlias;
 }
+
+// src/index.ts
+async function main() {
+  const workdir = process.cwd();
+  const config2 = await resolveConfig(workdir);
+  const client = createChannelClient(config2);
+  const pinStore = await loadPinStore();
+  const registry2 = createRegistryResolver(config2.registryURL);
+  const trust = new SenderTrustManager(
+    client,
+    registry2,
+    config2.teamID,
+    config2.did,
+    config2.stableID
+  );
+  const mcp = new Server(
+    { name: "aweb", version: "0.1.0" },
+    {
+      capabilities: {
+        experimental: { "claude/channel": {} }
+      },
+      instructions: `Events from the aweb channel are coordination messages from other agents in your team. Use the aw CLI to respond, not MCP tools.
+
+Mail events (type="mail") are async. Read them and act if needed. Confirmed channel delivery marks the source message handled so reconnects do not replay stale mail. Reply with: aw mail reply <message_id> --body "<reply>".
+
+Chat events (type="chat") may have sender_waiting="true", meaning the sender is blocked waiting for your reply. Respond promptly with: aw chat send-and-wait <from> "<reply>"
+If you need more time, send a status update the same way.
+
+Control events (type="control") are operational signals. On "pause", stop current work and wait. On "resume", continue. On "interrupt", stop and await new instructions.`
+    }
+  );
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+  const abort = new AbortController();
+  process.on("SIGINT", () => abort.abort());
+  process.on("SIGTERM", () => abort.abort());
+  await startChannelLoop({
+    client,
+    pinStore,
+    trust,
+    self: {
+      alias: config2.alias,
+      address: config2.address,
+      did: config2.did,
+      stableID: config2.stableID
+    },
+    signal: abort.signal,
+    workdir,
+    onAwakening: (awakening) => mcp.notification({
+      method: "notifications/claude/channel",
+      params: { content: awakening.content, meta: awakening.meta }
+    }),
+    log: (message) => console.error(message)
+  });
+}
+async function dispatchEvent(mcp, client, pinStore, trust, self, dispatched, event) {
+  await dispatchAgentEvent(
+    {
+      client,
+      pinStore,
+      trust,
+      self,
+      onAwakening: (awakening) => mcp.notification({
+        method: "notifications/claude/channel",
+        params: { content: awakening.content, meta: awakening.meta }
+      })
+    },
+    dispatched,
+    event
+  );
+}
 function isDirectExecution(moduleURL) {
   const entry = process.argv[1];
   if (!entry) return false;
@@ -27009,7 +27214,7 @@ if (isDirectExecution(import.meta.url)) {
 export {
   dispatchEvent,
   isDirectExecution,
-  resolveRegistryFallbackURL2 as resolveRegistryFallbackURL
+  resolveRegistryFallbackURL
 };
 /*! Bundled license information:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awebai/claude-channel",
-  "version": "1.4.10",
+  "version": "1.4.11",
   "mcpName": "io.github.awebai/channel",
   "license": "MIT",
   "type": "module",