@qwen-code/qwen-code 0.21.2 → 0.21.3

package/chunks/{dist-26BIMQT6.js → dist-4KAX7CCL.js}

@@ -3,8 +3,9 @@
 import {
   PollingChannelBase,
   getGlobalQwenDir,
+  getWorkspaceScopeDirName,
   sanitizeLogText
-} from "./chunk-JCJ7LKNA.js";
+} from "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import {
@@ -125,9 +126,9 @@ init_esbuild_shims();
 
 // packages/channels/github/dist/GithubAdapter.js
 init_esbuild_shims();
-import { createHash } from "node:crypto";
-import { appendFileSync, chmodSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import process2 from "node:process";
 
 // node_modules/@octokit/rest/dist-src/index.js
@@ -3863,8 +3864,7 @@ function isNoReplySentinel(text) {
 __name(isNoReplySentinel, "isNoReplySentinel");
 function isDefiniteNoWriteGithubError(err) {
   const e = err;
-  const remaining = Number(e.response?.headers?.["x-ratelimit-remaining"]);
-  return e.status === 429 || e.status === 403 && remaining === 0;
+  return (e.status === 403 || e.status === 429) && Number(e.response?.headers?.["x-ratelimit-remaining"]) === 0;
 }
 __name(isDefiniteNoWriteGithubError, "isDefiniteNoWriteGithubError");
 function parseTriggerKind(metadata) {
@@ -3881,6 +3881,11 @@ function buildTriggerGuidance(reason) {
   return `For ${reason}, output exactly ${NO_REPLY_SENTINEL} when a public reply is unnecessary.`;
 }
 __name(buildTriggerGuidance, "buildTriggerGuidance");
+function isPendingFinalDelivery(value) {
+  const item = value;
+  return item !== null && typeof item === "object" && typeof item.id === "string" && typeof item.createdAt === "string" && typeof item.chatId === "string" && typeof item.threadId === "string" && typeof item.fullText === "string" && typeof item.sessionId === "string";
+}
+__name(isPendingFinalDelivery, "isPendingFinalDelivery");
 var GithubChannel = class extends PollingChannelBase {
   static {
     __name(this, "GithubChannel");
@@ -3890,6 +3895,10 @@ var GithubChannel = class extends PollingChannelBase {
   webOrigin = "https://github.com";
   activeReactions = /* @__PURE__ */ new Map();
   reactionsPendingRemoval = /* @__PURE__ */ new Set();
+  pendingFinalDeliveryRetry;
+  pendingFinalDeliveryRetryAbort;
+  pendingFinalDeliveryRequestsActive = 0;
+  pendingFinalDeliveryRetryStopRequested = false;
   reasonFilter = null;
   constructor(name, config, bridge, options) {
     config.blockStreaming = "off";
@@ -3949,10 +3958,33 @@ var GithubChannel = class extends PollingChannelBase {
 `);
     }
     this.gate.replaceAllowedUsers(allowed);
+    this.migrateLegacyPublicationState();
+    this.pendingFinalDeliveryRetryStopRequested = false;
     this.startPollLoop();
+    if (this.pendingFinalDeliveryRetry) {
+      return;
+    }
+    const retryAbort = new AbortController();
+    const retry = this.retryPendingFinalDeliveries(retryAbort.signal).catch((err) => {
+      if (!retryAbort.signal.aborted) {
+        process2.stderr.write(`[Channel:${this.name}] pending GitHub delivery retry failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+      }
+    }).finally(() => {
+      if (this.pendingFinalDeliveryRetry === retry) {
+        this.pendingFinalDeliveryRetry = void 0;
+        this.pendingFinalDeliveryRetryAbort = void 0;
+      }
+    });
+    this.pendingFinalDeliveryRetryAbort = retryAbort;
+    this.pendingFinalDeliveryRetry = retry;
   }
   disconnect() {
     this.stopPollLoop();
+    this.pendingFinalDeliveryRetryStopRequested = true;
+    if (this.pendingFinalDeliveryRequestsActive === 0) {
+      this.pendingFinalDeliveryRetryAbort?.abort();
+    }
   }
   async sendMessage(_chatId, _text) {
     throw new Error(`[Channel:${this.name}] sendMessage requires a threadId; use sendThreadMessage`);
@@ -3966,18 +3998,15 @@ var GithubChannel = class extends PollingChannelBase {
   async publishFinalResponse(chatId, threadId, fullText, sessionId) {
     const threadMatch = threadId?.match(/^(issue|pr):(\d+)$/);
     const metadata = this.getResponseMetadata(sessionId);
-    const auditBase = {
-      channel: this.name,
-      triggerKind: parseTriggerKind(metadata),
-      repository: chatId,
-      number: threadMatch ? Number(threadMatch[2]) : void 0,
+    const auditBase = this.buildPublicationAuditBase({
+      chatId,
+      threadId,
+      fullText,
       sessionId,
       sourceMessageId: this.getResponseMessageId(sessionId),
       actor: this.getResponseSenderId(sessionId),
-      threadId,
-      bodySha256: createHash("sha256").update(fullText).digest("hex"),
-      bodyChars: Array.from(fullText).length
-    };
+      metadata
+    });
     if (isNoReplySentinel(fullText)) {
       this.recordPublicationAudit({
         ...auditBase,
@@ -4012,10 +4041,181 @@ var GithubChannel = class extends PollingChannelBase {
         failurePhase: "delivery",
         failureError: sanitizeLogText(err instanceof Error ? err.message : String(err), 200)
       });
+      if (threadId && isDefiniteNoWriteGithubError(err)) {
+        this.enqueuePendingFinalDelivery({
+          ...auditBase,
+          chatId,
+          threadId,
+          fullText
+        });
+      }
       throw new FinalPublicationError(err instanceof Error ? err.message : String(err), { cause: err });
     }
   }
-  async createIssueComment(chatId, threadId, text, retries = 3, shouldRetry = () => true) {
+  buildPublicationAuditBase(input) {
+    const threadMatch = input.threadId?.match(/^(issue|pr):(\d+)$/);
+    return {
+      channel: this.name,
+      triggerKind: parseTriggerKind(input.metadata),
+      repository: input.chatId,
+      number: threadMatch ? Number(threadMatch[2]) : void 0,
+      sessionId: input.sessionId,
+      sourceMessageId: input.sourceMessageId,
+      actor: input.actor,
+      threadId: input.threadId,
+      bodySha256: createHash("sha256").update(input.fullText).digest("hex"),
+      bodyChars: Array.from(input.fullText).length
+    };
+  }
+  enqueuePendingFinalDelivery(input) {
+    const record = {
+      id: createHash("sha256").update(JSON.stringify([
+        input.chatId,
+        input.threadId,
+        input.sessionId,
+        input.sourceMessageId ?? randomUUID(),
+        input.bodySha256
+      ])).digest("hex"),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      chatId: input.chatId,
+      threadId: input.threadId,
+      fullText: input.fullText,
+      sessionId: input.sessionId,
+      sourceMessageId: input.sourceMessageId,
+      actor: input.actor,
+      triggerKind: input.triggerKind
+    };
+    try {
+      const pending = this.readPendingFinalDeliveries().filter((item) => item.id !== record.id);
+      this.writePendingFinalDeliveries([...pending, record]);
+    } catch (err) {
+      process2.stderr.write(`[Channel:${this.name}] failed to persist pending GitHub delivery: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+    }
+  }
+  async retryPendingFinalDeliveries(signal) {
+    const pending = this.readPendingFinalDeliveries();
+    for (const record of pending) {
+      if (signal?.aborted)
+        return;
+      const auditBase = this.buildPublicationAuditBase({
+        chatId: record.chatId,
+        threadId: record.threadId,
+        fullText: record.fullText,
+        sessionId: record.sessionId,
+        sourceMessageId: record.sourceMessageId,
+        actor: record.actor,
+        metadata: record.triggerKind ? `Trigger: ${record.triggerKind}.` : void 0
+      });
+      if (this.hasPostedPublicationAudit(record.id)) {
+        process2.stderr.write(`[Channel:${this.name}] dropping pending GitHub delivery already recorded as posted: ${sanitizeLogText(record.id, 80)}
+`);
+        this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id));
+        continue;
+      }
+      try {
+        const comment = await this.createIssueComment(record.chatId, record.threadId, record.fullText, 3, isDefiniteNoWriteGithubError, signal);
+        this.recordPublicationAudit({
+          ...auditBase,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "github_publication",
+          outcome: "posted",
+          pendingId: record.id,
+          commentId: comment.id,
+          commentUrl: comment.html_url
+        });
+        if (!this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id))) {
+          continue;
+        }
+      } catch (err) {
+        if (signal?.aborted)
+          return;
+        if (isDefiniteNoWriteGithubError(err)) {
+          continue;
+        }
+        this.recordPublicationAudit({
+          ...auditBase,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "github_publication",
+          outcome: "failed",
+          failurePhase: "delivery",
+          failureError: sanitizeLogText(err instanceof Error ? err.message : String(err), 200)
+        });
+        if (!this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id))) {
+          continue;
+        }
+      }
+    }
+  }
+  hasPostedPublicationAudit(pendingId) {
+    try {
+      return readFileSync(this.channelFilePath("github-audit.jsonl"), "utf-8").split("\n").some((line) => {
+        if (!line)
+          return false;
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          return false;
+        }
+        return record.outcome === "posted" && record.pendingId === pendingId;
+      });
+    } catch {
+      return false;
+    }
+  }
+  updatePendingFinalDeliveries(update) {
+    try {
+      this.writePendingFinalDeliveries(update(this.readPendingFinalDeliveries(true)));
+      return true;
+    } catch (err) {
+      process2.stderr.write(`[Channel:${this.name}] failed to update pending GitHub deliveries: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+      return false;
+    }
+  }
+  pendingFinalDeliveriesPath() {
+    return this.channelFilePath("github-pending-deliveries.json");
+  }
+  readPendingFinalDeliveries(strict = false) {
+    try {
+      const parsed = JSON.parse(readFileSync(this.pendingFinalDeliveriesPath(), "utf-8"));
+      return Array.isArray(parsed) ? parsed.filter(isPendingFinalDelivery) : [];
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        process2.stderr.write(`[Channel:${this.name}] failed to read pending GitHub deliveries: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+        if (strict)
+          throw err;
+      }
+      return [];
+    }
+  }
+  writePendingFinalDeliveries(records) {
+    const path = this.pendingFinalDeliveriesPath();
+    if (records.length === 0) {
+      try {
+        unlinkSync(path);
+      } catch (err) {
+        if (err.code !== "ENOENT")
+          throw err;
+      }
+      return;
+    }
+    const dir = join(getGlobalQwenDir(), "channels", getWorkspaceScopeDirName(this.config.cwd));
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+    const tmpPath = `${path}.${process2.pid}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(records)}
+`, {
+      encoding: "utf-8",
+      mode: 384
+    });
+    chmodSync(tmpPath, 384);
+    renameSync(tmpPath, path);
+    chmodSync(path, 384);
+  }
+  async createIssueComment(chatId, threadId, text, retries = 3, shouldRetry = () => true, signal) {
     if (!threadId) {
       throw new Error(`[Channel:${this.name}] createIssueComment requires a threadId`);
     }
@@ -4025,12 +4225,23 @@ var GithubChannel = class extends PollingChannelBase {
     }
     const issueNumber = Number(match[1]);
     const [owner, repo] = chatId.split("/");
-    const response = await this.githubApi(() => this.octokit.rest.issues.createComment({
-      owner,
-      repo,
-      issue_number: issueNumber,
-      body: text
-    }), `createComment(${threadId})`, retries, shouldRetry);
+    const response = await this.githubApi(async () => {
+      this.pendingFinalDeliveryRequestsActive += 1;
+      try {
+        return await this.octokit.rest.issues.createComment({
+          owner,
+          repo,
+          issue_number: issueNumber,
+          body: text,
+          ...signal ? { request: { signal } } : {}
+        });
+      } finally {
+        this.pendingFinalDeliveryRequestsActive -= 1;
+        if (this.pendingFinalDeliveryRequestsActive === 0 && this.pendingFinalDeliveryRetryStopRequested) {
+          this.pendingFinalDeliveryRetryAbort?.abort();
+        }
+      }
+    }, `createComment(${threadId})`, retries, shouldRetry, signal);
     return response.data;
   }
   /**
@@ -4389,9 +4600,8 @@ ${summary}`,
   }
   recordPublicationAudit(record) {
     try {
-      const encodedName = this.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 200);
-      const dir = join(getGlobalQwenDir(), "channels");
-      const path = join(dir, `${encodedName}-github-audit.jsonl`);
+      const dir = join(getGlobalQwenDir(), "channels", getWorkspaceScopeDirName(this.config.cwd));
+      const path = this.channelFilePath("github-audit.jsonl");
       mkdirSync(dir, { recursive: true, mode: 448 });
       chmodSync(dir, 448);
       appendFileSync(path, `${JSON.stringify(record)}
@@ -4405,6 +4615,35 @@ ${summary}`,
 `);
     }
   }
+  migrateLegacyPublicationState() {
+    try {
+      const channelsRoot = join(getGlobalQwenDir(), "channels");
+      const encodedName = this.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 200);
+      const sentinel = this.channelFilePath("github-state-migrated");
+      if (existsSync(sentinel))
+        return;
+      mkdirSync(dirname(sentinel), { recursive: true, mode: 448 });
+      for (const suffix of [
+        "github-pending-deliveries.json",
+        "github-audit.jsonl"
+      ]) {
+        const legacyPath = join(channelsRoot, `${encodedName}-${suffix}`);
+        const scopedPath = this.channelFilePath(suffix);
+        if (!existsSync(scopedPath) && existsSync(legacyPath)) {
+          renameSync(legacyPath, scopedPath);
+        }
+      }
+      writeFileSync(sentinel, "", { mode: 384 });
+    } catch (err) {
+      process2.stderr.write(`[Channel:${this.name}] legacy GitHub state migration failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+    }
+  }
+  channelFilePath(suffix) {
+    const encodedName = this.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 200);
+    const nameHash = createHash("sha256").update(this.name).digest("hex").slice(0, 16);
+    return join(getGlobalQwenDir(), "channels", getWorkspaceScopeDirName(this.config.cwd), `${encodedName}-${nameHash}-${suffix}`);
+  }
   extractFromSubjectUrl(url) {
     const match = url.match(/\/repos\/([^/]+\/[^/]+)\/(issues|pulls)\/(\d+)/);
     if (!match)
@@ -4426,11 +4665,15 @@ ${GITHUB_PUBLICATION_INSTRUCTIONS}
 Trigger: ${ctx.reason}.
 ${buildTriggerGuidance(ctx.reason)}`;
   }
-  async githubApi(fn, label, retries = 3, shouldRetry = () => true) {
+  async githubApi(fn, label, retries = 3, shouldRetry = () => true, signal) {
     for (let attempt = 1; attempt <= retries; attempt++) {
+      if (signal?.aborted)
+        throw new Error(`${label} aborted`);
       try {
         return await fn();
       } catch (err) {
+        if (signal?.aborted)
+          throw err;
         if (attempt === retries || !shouldRetry(err))
           throw err;
         const e = err;
@@ -4446,11 +4689,30 @@ ${buildTriggerGuidance(ctx.reason)}`;
         }
         process2.stderr.write(`[Channel:${this.name}] ${label} failed (attempt ${attempt}/${retries}, status=${e.status}), retrying in ${cooldown}ms: ${e.message}
 `);
-        await this.abortableSleep(cooldown);
+        await this.sleepForRetry(cooldown, signal);
       }
     }
     throw new Error("unreachable");
   }
+  sleepForRetry(ms, signal) {
+    if (!signal)
+      return this.abortableSleep(ms);
+    return new Promise((resolve) => {
+      if (signal.aborted) {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = /* @__PURE__ */ __name(() => {
+        clearTimeout(timer);
+        resolve();
+      }, "onAbort");
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
   async markNotificationsAsRead(lastReadAt) {
     await this.githubApi(() => this.octokit.rest.activity.markNotificationsAsRead({
       last_read_at: lastReadAt,

package/chunks/{dist-OAOC5OV4.js → dist-7JGAAQSC.js}

@@ -11,11 +11,11 @@ import {
   sendMessage,
   sendTyping,
   uploadToCdn
-} from "./chunk-ZPZ7ZJEE.js";
+} from "./chunk-WUC6ZFXO.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType
-} from "./chunk-JCJ7LKNA.js";
+} from "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import {

package/chunks/{dist-SL2LUMML.js → dist-A7H2KKUC.js}

@@ -12,7 +12,7 @@ import {
   isTerminalTaskLifecycleType,
   sanitizeLogText,
   sanitizeSenderName
-} from "./chunk-JCJ7LKNA.js";
+} from "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-CR3C7WXL.js";

package/chunks/{dist-2PERFI23.js → dist-DPPHJAVL.js}

@@ -4,18 +4,18 @@ import {
   require_axios,
   require_ws
 } from "./chunk-I3G5JWBV.js";
+import "./chunk-JE7KQ2UP.js";
+import "./chunk-K6KS3LTN.js";
 import {
   require_lib
 } from "./chunk-FC4KQFCS.js";
-import "./chunk-JE7KQ2UP.js";
-import "./chunk-K6KS3LTN.js";
 import "./chunk-T3CHYWJZ.js";
 import {
   ChannelBase,
   ChannelProactiveDeliveryError,
   isChannelProactiveDeliveryError,
   isTerminalTaskLifecycleType
-} from "./chunk-JCJ7LKNA.js";
+} from "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import {

package/chunks/{dist-PVEAFLHY.js → dist-HVBMEYWK.js}

@@ -10,7 +10,7 @@ import "./chunk-T3CHYWJZ.js";
 import {
   ChannelBase,
   sanitizeLogText
-} from "./chunk-JCJ7LKNA.js";
+} from "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-CR3C7WXL.js";

package/chunks/{dist-ULIG4M5H.js → dist-NEBRI7WO.js}

@@ -6,7 +6,7 @@ import {
 import "./chunk-T3CHYWJZ.js";
 import {
   PollingChannelBase
-} from "./chunk-JCJ7LKNA.js";
+} from "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import {
   external_exports
@@ -13197,6 +13197,7 @@ var GitlabChannel = class extends PollingChannelBase {
   apiHost = "https://gitlab.com";
   botUsername = "";
   descriptionCache = /* @__PURE__ */ new Map();
+  reactions = /* @__PURE__ */ new Map();
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
   }
@@ -13246,6 +13247,35 @@ var GitlabChannel = class extends PollingChannelBase {
     const targetType = threadId.startsWith("mr:") ? "mr" : "issue";
     await this.createNote(chatId, targetType, Number(match[1]), text);
   }
+  onPromptStart(chatId, _sessionId, messageId) {
+    if (!messageId)
+      return;
+    const entry = this.reactions.get(messageId);
+    if (!entry || entry.award)
+      return;
+    const api = entry.target.isMr ? this.api.MergeRequestNoteAwardEmojis : this.api.IssueNoteAwardEmojis;
+    entry.award = api.award(chatId, entry.target.iid, entry.noteId, "eyes").then((r) => ({ awardId: r.id }));
+    void entry.award.catch((err) => {
+      entry.award = void 0;
+      process2.stderr.write(`[Channel:${this.name}] failed to acknowledge note ${entry.noteId}: ${err}
+`);
+    });
+  }
+  onPromptEnd(chatId, _sessionId, messageId) {
+    if (!messageId)
+      return;
+    const entry = this.reactions.get(messageId);
+    if (!entry)
+      return;
+    this.reactions.delete(messageId);
+    if (!entry.award)
+      return;
+    const api = entry.target.isMr ? this.api.MergeRequestNoteAwardEmojis : this.api.IssueNoteAwardEmojis;
+    void entry.award.then(({ awardId }) => api.remove(chatId, entry.target.iid, entry.noteId, awardId)).catch((err) => {
+      process2.stderr.write(`[Channel:${this.name}] failed to remove acknowledgement from note ${entry.noteId}: ${err}
+`);
+    });
+  }
   async pollOnce() {
     const templates = this.config.action_prompt_template;
     if (!templates || Object.keys(templates).length === 0)
@@ -13275,25 +13305,33 @@ var GitlabChannel = class extends PollingChannelBase {
       }
     }
     for (const todo of todos) {
-      if (!todo.project || !todo.target || !todo.target.iid || todo.target_type !== "Issue" && todo.target_type !== "MergeRequest") {
+      if (!todo.project || todo.target_type !== "Issue" && todo.target_type !== "MergeRequest") {
         await this.skipTodo(todo);
         continue;
       }
+      const raw = todo.target || {};
+      if (!raw.iid) {
+        await this.skipTodo(todo);
+        continue;
+      }
+      const target = {
+        iid: raw.iid,
+        title: raw.title ?? "",
+        isMr: todo.target_type === "MergeRequest"
+      };
       const template = this.resolveTemplate(templates, todo.action_name);
       if (!template) {
         await this.skipTodo(todo);
         continue;
       }
       const chatId = todo.project.path_with_namespace;
-      const targetType = todo.target_type === "MergeRequest" ? "mr" : "issue";
-      const threadId = `${targetType}:${todo.target.iid}`;
       try {
-        await this.processTodo(todo, template, chatId, targetType, threadId);
+        await this.processTodo(todo, target, template, chatId);
       } catch (err) {
         process2.stderr.write(`[Channel:${this.name}] error processing todo ${todo.id}: ${err}
 `);
         try {
-          await this.createNote(chatId, targetType, todo.target.iid, "\u26A0\uFE0F Failed to process this request. Please re-mention the bot to retry.");
+          await this.createNote(chatId, target.isMr ? "mr" : "issue", target.iid, "\u26A0\uFE0F Failed to process this request. Please re-mention the bot to retry.");
         } catch {
         }
       }
@@ -13318,29 +13356,43 @@ var GitlabChannel = class extends PollingChannelBase {
       return templates["mentioned"];
     return void 0;
   }
-  async processTodo(todo, template, chatId, targetType, threadId) {
+  async processTodo(todo, target, template, chatId) {
     if (todo.author.username === this.botUsername)
       return;
-    const isNoteMention = /#note_\d+$/.test(todo.target_url);
+    const targetType = target.isMr ? "mr" : "issue";
+    const threadId = `${targetType}:${target.iid}`;
+    const noteMatch = todo.target_url.match(/#note_(\d+)$/);
+    const isNoteMention = noteMatch !== null;
+    const messageId = String(todo.id);
     const needsDescription = !isNoteMention || template.includes("%description%");
     let description = "";
     if (needsDescription) {
       if (isNoteMention) {
         try {
-          description = await this.fetchDescription(chatId, targetType, todo.target.iid);
+          description = await this.fetchDescription(chatId, targetType, target.iid);
         } catch (err) {
           process2.stderr.write(`[Channel:${this.name}] fetchDescription failed (metadata only): ${err}
 `);
         }
       } else {
-        description = await this.fetchDescription(chatId, targetType, todo.target.iid);
+        description = await this.fetchDescription(chatId, targetType, target.iid);
       }
     }
     const text = isNoteMention ? todo.body || "" : description || todo.body || "";
     if (!text)
       return;
-    const envelope = this.buildEnvelope(text, todo.author.username, chatId, threadId, String(todo.id), this.buildMetadata(template, todo, chatId, todo.author.username, String(todo.id), description), true);
-    await this.handleInbound(envelope);
+    const envelope = this.buildEnvelope(text, todo.author.username, chatId, threadId, messageId, this.buildMetadata(template, todo, target, chatId, todo.author.username, String(todo.id), description), true);
+    if (isNoteMention) {
+      this.reactions.set(messageId, {
+        target,
+        noteId: Number(noteMatch[1])
+      });
+    }
+    try {
+      await this.handleInbound(envelope);
+    } finally {
+      this.reactions.delete(messageId);
+    }
   }
   async fetchDescription(chatId, targetType, iid) {
     const cacheKey = `${chatId}/${targetType}/${iid}`;
@@ -13374,14 +13426,14 @@ var GitlabChannel = class extends PollingChannelBase {
       metadata
     };
   }
-  buildMetadata(template, todo, chatId, author, commentId, description) {
+  buildMetadata(template, todo, target, chatId, author, commentId, description) {
     const vars = {
       project: chatId,
       project_url: `${this.apiHost}/${chatId}`,
       author,
       target_type: todo.target_type,
-      iid: String(todo.target.iid),
-      title: todo.target.title,
+      iid: String(target.iid),
+      title: target.title,
       description,
       todo_id: commentId
     };