@qwen-code/qwen-code 0.21.2 → 0.21.3-nightly.20260803.e1e5b42ce

package/chunks/{dist-26BIMQT6.js → dist-IKGVITP3.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
@@ -3840,6 +3841,27 @@ function normalizeReasonFilter(config, channelName) {
   return reasons.length > 0 ? new Set(reasons) : null;
 }
 __name(normalizeReasonFilter, "normalizeReasonFilter");
+var MAX_INBOUND_TASK_ATTEMPTS = 3;
+function isOptionalStringArray(value) {
+  return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+__name(isOptionalStringArray, "isOptionalStringArray");
+function isInboundEnvelope(value) {
+  if (value === void 0)
+    return true;
+  if (value === null || typeof value !== "object")
+    return false;
+  const envelope = value;
+  return typeof envelope.channelName === "string" && typeof envelope.senderId === "string" && typeof envelope.senderName === "string" && typeof envelope.chatId === "string" && typeof envelope.text === "string" && typeof envelope.isGroup === "boolean" && typeof envelope.isMentioned === "boolean" && typeof envelope.isReplyToBot === "boolean" && (envelope.chatName === void 0 || typeof envelope.chatName === "string") && (envelope.threadId === void 0 || typeof envelope.threadId === "string") && (envelope.messageId === void 0 || typeof envelope.messageId === "string") && (envelope.referencedText === void 0 || typeof envelope.referencedText === "string") && (envelope.imageBase64 === void 0 || typeof envelope.imageBase64 === "string") && (envelope.imageMimeType === void 0 || typeof envelope.imageMimeType === "string") && (envelope.attachments === void 0 || Array.isArray(envelope.attachments)) && (envelope.metadata === void 0 || typeof envelope.metadata === "string") && (envelope.alreadyPrefixed === void 0 || envelope.alreadyPrefixed === true);
+}
+__name(isInboundEnvelope, "isInboundEnvelope");
+function isInboundTaskRecord(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const record = value;
+  return record.version === 1 && typeof record.id === "string" && typeof record.createdAt === "string" && typeof record.updatedAt === "string" && ["accepted", "running", "reply_pending", "failed", "cancelled"].includes(record.state) && Number.isSafeInteger(record.issueNumber) && record.source !== null && typeof record.source === "object" && typeof record.source.chatId === "string" && (record.source.threadId === void 0 || typeof record.source.threadId === "string") && (record.source.messageId === void 0 || typeof record.source.messageId === "string") && isInboundEnvelope(record.envelope) && record.dedupe !== null && typeof record.dedupe === "object" && isOptionalStringArray(record.dedupe.dispatchedBodies) && isOptionalStringArray(record.dedupe.dispatchedComments) && isOptionalStringArray(record.dedupe.dispatchedEvents) && (record.attempts === void 0 || Number.isSafeInteger(record.attempts) && record.attempts >= 0) && (record.errorCommentPosted === void 0 || typeof record.errorCommentPosted === "boolean") && (record.error === void 0 || typeof record.error === "string");
+}
+__name(isInboundTaskRecord, "isInboundTaskRecord");
 var FinalPublicationError = class extends Error {
   static {
     __name(this, "FinalPublicationError");
@@ -3863,8 +3885,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 +3902,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,7 +3916,17 @@ 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;
+  inboundRecoveryPending = true;
+  recoverableInboundTasks = 0;
+  activeInboundTaskIdsByMessage = /* @__PURE__ */ new Map();
+  cancelledInboundTaskIds = /* @__PURE__ */ new Set();
+  pendingCursorUpdatedAt;
+  inboundPersistenceBlocked = false;
   constructor(name, config, bridge, options) {
     config.blockStreaming = "off";
     config.instructions = [
@@ -3949,10 +3985,40 @@ var GithubChannel = class extends PollingChannelBase {
 `);
     }
     this.gate.replaceAllowedUsers(allowed);
+    this.migrateLegacyPublicationState();
+    this.inboundPersistenceBlocked = false;
+    this.inboundRecoveryPending = true;
+    try {
+      this.recoverableInboundTasks = this.readInboundTasks().filter((record) => this.isRecoverableInboundTask(record)).length;
+    } catch {
+      this.recoverableInboundTasks = 0;
+    }
+    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 +4032,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,
@@ -3993,6 +4056,12 @@ var GithubChannel = class extends PollingChannelBase {
     if (!threadMatch) {
       throw new Error(`[Channel:${this.name}] invalid threadId format: ${threadId}`);
     }
+    this.recordPublicationAudit({
+      ...auditBase,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "github_publication",
+      outcome: "posting"
+    });
     try {
       const comment = await this.createIssueComment(chatId, threadId, fullText, 3, isDefiniteNoWriteGithubError);
       this.recordPublicationAudit({
@@ -4012,10 +4081,196 @@ var GithubChannel = class extends PollingChannelBase {
         failurePhase: "delivery",
         failureError: sanitizeLogText(err instanceof Error ? err.message : String(err), 200)
       });
+      if (threadId && isDefiniteNoWriteGithubError(err)) {
+        try {
+          this.enqueuePendingFinalDelivery({
+            ...auditBase,
+            chatId,
+            threadId,
+            fullText
+          });
+        } catch (persistError) {
+          throw new Error(`[Channel:${this.name}] failed to persist pending GitHub delivery: ${sanitizeLogText(persistError instanceof Error ? persistError.message : String(persistError), 200)}`, { cause: persistError });
+        }
+      }
       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
+    };
+    const pending = this.readPendingFinalDeliveries(true).filter((item) => item.id !== record.id);
+    this.writePendingFinalDeliveries([...pending, record]);
+  }
+  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)}
+`);
+        if (this.updatePendingFinalDeliveries((current) => current.filter((item) => item.id !== record.id))) {
+          this.removeReplyPendingInboundTask(record);
+        }
+        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;
+        }
+        this.removeReplyPendingInboundTask(record);
+      } 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;
+        }
+        this.removeReplyPendingInboundTask(record);
+      }
+    }
+  }
+  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;
+    }
+  }
+  removeReplyPendingInboundTask(delivery) {
+    try {
+      const tasks = this.readInboundTasks();
+      const matching = tasks.filter((task) => task.state === "reply_pending" && task.source.chatId === delivery.chatId && task.source.threadId === delivery.threadId && task.source.messageId === delivery.sourceMessageId);
+      for (const task of matching) {
+        this.removeInboundTask(task.id);
+      }
+    } catch (cleanupErr) {
+      process2.stderr.write(`[Channel:${this.name}] failed to clean up inbound task: ${sanitizeLogText(cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr), 200)}
+`);
+    }
+  }
+  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 +4280,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;
   }
   /**
@@ -4099,15 +4365,25 @@ var GithubChannel = class extends PollingChannelBase {
     });
   }
   async pollOnce() {
+    this.inboundPersistenceBlocked = false;
+    if (this.inboundRecoveryPending) {
+      try {
+        await this.recoverInboundTasks();
+      } catch (err) {
+        process2.stderr.write(`[Channel:${this.name}] inbound task recovery failed, will retry next poll: ${err}
+`);
+      } finally {
+        this.inboundRecoveryPending = false;
+      }
+    }
     this.cursor.metaFloor ??= this.cursor.lastProcessedAt;
     const since = new Date(new Date(this.cursor.lastProcessedAt).getTime() - 1e3).toISOString();
     const notifications = await this.githubApi(() => this.octokit.paginate(this.octokit.rest.activity.listNotificationsForAuthenticatedUser, { since, per_page: 100 }), "listNotifications");
     notifications.sort((a, b) => a.updated_at.localeCompare(b.updated_at));
     const maxUpdatedAt = notifications.length > 0 ? notifications[notifications.length - 1].updated_at : this.cursor.lastProcessedAt;
     const windowSince = this.cursor.lastProcessedAt;
-    await this.markNotificationsAsRead(maxUpdatedAt);
     if (maxUpdatedAt > this.cursor.lastProcessedAt) {
-      this.cursor.lastProcessedAt = maxUpdatedAt;
+      this.pendingCursorUpdatedAt = !this.pendingCursorUpdatedAt || maxUpdatedAt > this.pendingCursorUpdatedAt ? maxUpdatedAt : this.pendingCursorUpdatedAt;
     }
     for (const notification of notifications) {
       if (!notification.subject.url)
@@ -4171,6 +4447,17 @@ var GithubChannel = class extends PollingChannelBase {
         continue;
       }
     }
+    if (this.hasRecoverableInboundTasks()) {
+      this.inboundRecoveryPending = true;
+    }
+    if (!this.inboundPersistenceBlocked && !this.hasRecoverableInboundTasks() && this.pendingCursorUpdatedAt) {
+      const committedAt = this.pendingCursorUpdatedAt;
+      await this.markNotificationsAsRead(committedAt);
+      if (committedAt > this.cursor.lastProcessedAt) {
+        this.cursor.lastProcessedAt = committedAt;
+      }
+      this.pendingCursorUpdatedAt = void 0;
+    }
   }
   async processCommentLane(ctx, onlyMentioned, directed = false) {
     const comments = await this.fetchNewComments(ctx);
@@ -4198,7 +4485,9 @@ var GithubChannel = class extends PollingChannelBase {
         isReplyToBot: false,
         metadata: this.buildRouteMetadata(ctx)
       };
-      if (!await this.dispatchEnvelope(envelope, ctx.issueNumber)) {
+      if (!await this.dispatchEnvelope(envelope, ctx.issueNumber, {
+        dispatchedComments: [key]
+      })) {
         dispatched = true;
         continue;
       }
@@ -4238,7 +4527,9 @@ Trigger: ${reason}.
 ${buildTriggerGuidance(reason)}
 ${details}`
     };
-    await this.dispatchEnvelope(envelope, ctx.issueNumber);
+    await this.dispatchEnvelope(envelope, ctx.issueNumber, {
+      dispatchedEvents: [trigger.key]
+    });
     this.recordDispatched("dispatchedEvents", trigger.key);
   }
   async processAggregateLane(ctx) {
@@ -4273,7 +4564,9 @@ ${summary}`,
       isReplyToBot: false,
       metadata: this.buildRouteMetadata(ctx)
     };
-    await this.dispatchEnvelope(envelope, ctx.issueNumber);
+    await this.dispatchEnvelope(envelope, ctx.issueNumber, {
+      dispatchedComments: allComments.map((comment) => comment.node_id || String(comment.id))
+    });
   }
   async findDirectTrigger(ctx, reason) {
     const [owner, repo] = ctx.chatId.split("/");
@@ -4355,7 +4648,9 @@ ${summary}`,
         isReplyToBot: false,
         metadata: this.buildRouteMetadata(ctx)
       };
-      await this.dispatchEnvelope(envelope, issueNumber);
+      await this.dispatchEnvelope(envelope, issueNumber, {
+        dispatchedBodies: [bodyKey]
+      });
       this.recordDispatchedBody(bodyKey);
     } catch (err) {
       process2.stderr.write(`[Channel:${this.name}] failed to fetch issue for first contact: ${err}
@@ -4374,24 +4669,235 @@ ${summary}`,
       list.push(key);
     this.cursor[field] = list.slice(-MAX_DISPATCHED);
   }
-  async dispatchEnvelope(envelope, issueNumber) {
+  async dispatchEnvelope(envelope, issueNumber, dedupe = {}) {
+    const task = this.claimInboundTask(envelope, issueNumber, dedupe);
+    return this.runInboundTask(task);
+  }
+  claimInboundTask(envelope, issueNumber, dedupe) {
+    const existing = this.readInboundTasks().find((record) => record.source.chatId === envelope.chatId && record.source.threadId === envelope.threadId && record.source.messageId === envelope.messageId);
+    if (existing) {
+      this.applyTaskDedupe(existing);
+      return existing;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      version: 1,
+      id: randomUUID(),
+      createdAt: now,
+      updatedAt: now,
+      state: "accepted",
+      issueNumber,
+      source: {
+        chatId: envelope.chatId,
+        threadId: envelope.threadId,
+        messageId: envelope.messageId
+      },
+      envelope,
+      dedupe,
+      attempts: 0
+    };
+    this.updateInboundTasks((records) => [...records, task]);
+    this.applyTaskDedupe(task);
+    return task;
+  }
+  async runInboundTask(task) {
+    if (!this.isRecoverableInboundTask(task))
+      return true;
+    const envelope = task.envelope;
+    if (!envelope)
+      return true;
+    const attempts = (task.attempts ?? 0) + 1;
+    this.activeInboundTaskIdsByMessage.set(this.inboundMessageKey(envelope.chatId, envelope.messageId), task.id);
+    this.transitionInboundTask(task.id, "running", { attempts });
+    let cancelled = false;
     try {
       await this.handleInbound(envelope);
-      return true;
+      cancelled = this.cancelledInboundTaskIds.has(task.id);
     } catch (err) {
+      const error = sanitizeLogText(err instanceof Error ? err.message : String(err), 200);
       process2.stderr.write(`[Channel:${this.name}] handleInbound failed for ${envelope.messageId}: ${err}
 `);
-      if (!(err instanceof FinalPublicationError)) {
-        await this.postErrorComment(envelope.chatId, issueNumber);
+      if (err instanceof FinalPublicationError) {
+        if (this.cancelledInboundTaskIds.has(task.id)) {
+        } else if (this.hasPendingFinalDeliveryForTask(task)) {
+          this.transitionInboundTask(task.id, "reply_pending", {
+            envelope: void 0,
+            error
+          });
+        } else {
+          this.removeInboundTask(task.id);
+        }
+      } else if (!this.cancelledInboundTaskIds.has(task.id)) {
+        let posted = task.errorCommentPosted === true;
+        if (!posted) {
+          posted = await this.postErrorComment(envelope.chatId, task.issueNumber);
+        }
+        this.transitionInboundTask(task.id, "failed", {
+          error,
+          attempts,
+          errorCommentPosted: posted
+        });
       }
       return false;
+    } finally {
+      this.activeInboundTaskIdsByMessage.delete(this.inboundMessageKey(envelope.chatId, envelope.messageId));
+      this.cancelledInboundTaskIds.delete(task.id);
+    }
+    if (cancelled)
+      return true;
+    if (this.hasPendingFinalDeliveryForTask(task)) {
+      this.transitionInboundTask(task.id, "reply_pending", {
+        envelope: void 0
+      });
+    } else {
+      this.removeInboundTask(task.id);
+    }
+    return true;
+  }
+  async recoverInboundTasks() {
+    const tasks = this.readInboundTasks().filter((task) => this.isRecoverableInboundTask(task));
+    const pendingDeliveries = tasks.length ? this.readPendingFinalDeliveries(true) : [];
+    const publicationAuditKeys = tasks.length ? this.readPublicationAuditKeys(true) : /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (!task.envelope)
+        continue;
+      this.applyTaskDedupe(task);
+      if (pendingDeliveries.some((record) => record.chatId === task.source.chatId && record.threadId === task.source.threadId && record.sourceMessageId === task.source.messageId)) {
+        this.transitionInboundTask(task.id, "reply_pending", {
+          envelope: void 0
+        });
+        continue;
+      }
+      if (publicationAuditKeys.has(this.inboundTaskSourceKey(task))) {
+        this.removeInboundTask(task.id);
+        continue;
+      }
+      await this.runInboundTask(task);
+    }
+  }
+  isRecoverableInboundTask(task) {
+    return task.state === "accepted" || task.state === "running" || task.state === "failed" && (task.attempts ?? 0) < MAX_INBOUND_TASK_ATTEMPTS;
+  }
+  hasRecoverableInboundTasks() {
+    return this.recoverableInboundTasks > 0;
+  }
+  hasPendingFinalDeliveryForTask(task) {
+    return this.readPendingFinalDeliveries(true).some((record) => record.chatId === task.source.chatId && record.threadId === task.source.threadId && record.sourceMessageId === task.source.messageId);
+  }
+  inboundTaskSourceKey(task) {
+    return `${task.source.chatId}|${task.source.threadId ?? ""}|${task.source.messageId ?? ""}`;
+  }
+  readPublicationAuditKeys(strict = false) {
+    try {
+      const keys = /* @__PURE__ */ new Set();
+      for (const line of readFileSync(this.channelFilePath("github-audit.jsonl"), "utf-8").split("\n")) {
+        if (!line)
+          continue;
+        try {
+          const record = JSON.parse(line);
+          if (record.outcome === "posted" || record.outcome === "suppressed" || record.outcome === "posting") {
+            keys.add(`${record.repository}|${record.threadId ?? ""}|${record.sourceMessageId ?? ""}`);
+          }
+        } catch {
+          continue;
+        }
+      }
+      return keys;
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return /* @__PURE__ */ new Set();
+      if (strict)
+        throw err;
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  applyTaskDedupe(task) {
+    for (const [field, keys] of Object.entries(task.dedupe)) {
+      for (const key of keys ?? []) {
+        this.recordDispatched(field, key);
+      }
+    }
+  }
+  transitionInboundTask(taskId, state, updates = {}) {
+    this.updateInboundTasks((records) => records.map((record) => record.id === taskId ? {
+      ...record,
+      ...updates,
+      state,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    } : record));
+  }
+  removeInboundTask(taskId) {
+    this.updateInboundTasks((records) => records.filter((record) => record.id !== taskId));
+  }
+  updateInboundTasks(update) {
+    try {
+      const records = update(this.readInboundTasks());
+      this.writeInboundTasks(records);
+      this.recoverableInboundTasks = records.filter((record) => this.isRecoverableInboundTask(record)).length;
+    } catch (err) {
+      this.inboundPersistenceBlocked = true;
+      throw err;
+    }
+  }
+  inboundTasksPath() {
+    return this.channelFilePath("github-inbound-tasks.json");
+  }
+  readInboundTasks() {
+    try {
+      const parsed = JSON.parse(readFileSync(this.inboundTasksPath(), "utf-8"));
+      if (!Array.isArray(parsed) || !parsed.every(isInboundTaskRecord)) {
+        throw new Error("invalid GitHub inbound task state");
+      }
+      return parsed;
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return [];
+      this.inboundPersistenceBlocked = true;
+      process2.stderr.write(`[Channel:${this.name}] failed to read GitHub inbound tasks: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+      throw err;
+    }
+  }
+  writeInboundTasks(records) {
+    const path = this.inboundTasksPath();
+    if (records.length === 0) {
+      try {
+        unlinkSync(path);
+      } catch (err) {
+        if (err.code !== "ENOENT")
+          throw err;
+      }
+      return;
+    }
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+    const tmpPath = `${path}.${process2.pid}.${randomUUID()}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(records)}
+`, {
+      encoding: "utf-8",
+      mode: 384
+    });
+    chmodSync(tmpPath, 384);
+    renameSync(tmpPath, path);
+    chmodSync(path, 384);
+  }
+  inboundMessageKey(chatId, messageId) {
+    return `${chatId}|${messageId ?? ""}`;
+  }
+  onTaskLifecycle(event) {
+    const taskId = this.activeInboundTaskIdsByMessage.get(this.inboundMessageKey(event.chatId, event.messageId));
+    if (!taskId)
+      return;
+    if (event.type === "cancelled") {
+      this.cancelledInboundTaskIds.add(taskId);
+      this.transitionInboundTask(taskId, "cancelled");
     }
   }
   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 +4911,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 +4961,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 +4985,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,
@@ -4465,9 +5023,11 @@ ${buildTriggerGuidance(ctx.reason)}`;
         issue_number: issueNumber,
         body: "\u26A0\uFE0F Failed to process this request. Please re-mention the bot to retry."
       }), `postErrorComment(${chatId}#${issueNumber})`);
+      return true;
     } catch (err) {
       process2.stderr.write(`[Channel:${this.name}] postErrorComment also failed for ${chatId}#${issueNumber}, user must re-mention manually: ${err}
 `);
+      return false;
     }
   }
 };
@@ -4479,6 +5039,85 @@ var plugin = {
   requiredConfigFields: ["token"],
   envResolvableConfigFields: ["baseUrl"],
   defaultSessionScope: "chat_thread",
+  management: {
+    fields: [
+      {
+        key: "token",
+        label: "Personal Access Token",
+        kind: "secret",
+        required: true,
+        envResolvable: true,
+        description: 'Classic PAT with "notifications" scope'
+      },
+      {
+        key: "baseUrl",
+        label: "Base URL",
+        kind: "string",
+        envResolvable: true,
+        description: "GitHub Enterprise API root (e.g. https://ghe.example.com/api/v3). Leave empty for github.com"
+      },
+      {
+        key: "groupPolicy",
+        label: "Group Policy",
+        kind: "enum",
+        required: true,
+        description: 'Must be "Open" for notifications to flow',
+        default: "open",
+        options: [
+          { value: "open", label: "Open" },
+          { value: "allowlist", label: "Allowlist" },
+          { value: "disabled", label: "Disabled" }
+        ]
+      },
+      {
+        key: "senderPolicy",
+        label: "Sender Policy",
+        kind: "enum",
+        required: true,
+        description: 'Use "Allowlist" with allowed users on public repos',
+        options: [
+          { value: "allowlist", label: "Allowlist" },
+          { value: "pairing", label: "Pairing" },
+          { value: "open", label: "Open" }
+        ]
+      },
+      {
+        key: "allowedUsers",
+        label: "Allowed Users",
+        kind: "string-list",
+        description: "GitHub usernames, used by Allowlist and Pairing policies"
+      },
+      {
+        key: "reasonFilter",
+        label: "Reason Filter",
+        kind: "string-list",
+        description: "Optional. Comma-separated notification reasons to process. Leave empty to process all.",
+        options: [
+          { value: "mention", label: "mention" },
+          { value: "review_requested", label: "review_requested" },
+          { value: "assign", label: "assign" },
+          { value: "author", label: "author" },
+          { value: "comment", label: "comment" },
+          { value: "ci_activity", label: "ci_activity" },
+          { value: "manual", label: "manual" },
+          { value: "state_change", label: "state_change" },
+          { value: "subscribed", label: "subscribed" },
+          { value: "team_mention", label: "team_mention" },
+          { value: "security_alert", label: "security_alert" },
+          { value: "approval_requested", label: "approval_requested" },
+          { value: "invitation", label: "invitation" },
+          {
+            value: "member_feature_requested",
+            label: "member_feature_requested"
+          },
+          {
+            value: "security_advisory_credit",
+            label: "security_advisory_credit"
+          }
+        ]
+      }
+    ]
+  },
   createChannel: /* @__PURE__ */ __name((name, config, bridge, options) => new GithubChannel(name, config, bridge, options), "createChannel")
 };
 export {