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

package/dist/GithubAdapter.js

@@ -1,10 +1,10 @@
-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 process from 'node:process';
 import { Octokit } from '@octokit/rest';
 import { HttpsProxyAgent } from 'https-proxy-agent';
-import { getGlobalQwenDir, PollingChannelBase, sanitizeLogText, } from '@qwen-code/channel-base';
+import { getGlobalQwenDir, getWorkspaceScopeDirName, PollingChannelBase, sanitizeLogText, } from '@qwen-code/channel-base';
 import { testBotMention, stripBotMention } from './mention.js';
 const KNOWN_NOTIFICATION_REASONS = new Set([
     'mention',
@@ -45,6 +45,73 @@ function normalizeReasonFilter(config, channelName) {
     }
     return reasons.length > 0 ? new Set(reasons) : null;
 }
+const MAX_INBOUND_TASK_ATTEMPTS = 3;
+function isOptionalStringArray(value) {
+    return (value === undefined ||
+        (Array.isArray(value) && value.every((item) => typeof item === 'string')));
+}
+function isInboundEnvelope(value) {
+    if (value === undefined)
+        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 === undefined ||
+            typeof envelope.chatName === 'string') &&
+        (envelope.threadId === undefined ||
+            typeof envelope.threadId === 'string') &&
+        (envelope.messageId === undefined ||
+            typeof envelope.messageId === 'string') &&
+        (envelope.referencedText === undefined ||
+            typeof envelope.referencedText === 'string') &&
+        (envelope.imageBase64 === undefined ||
+            typeof envelope.imageBase64 === 'string') &&
+        (envelope.imageMimeType === undefined ||
+            typeof envelope.imageMimeType === 'string') &&
+        (envelope.attachments === undefined ||
+            Array.isArray(envelope.attachments)) &&
+        (envelope.metadata === undefined ||
+            typeof envelope.metadata === 'string') &&
+        (envelope.alreadyPrefixed === undefined ||
+            envelope.alreadyPrefixed === true));
+}
+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 === undefined ||
+            typeof record.source.threadId === 'string') &&
+        (record.source.messageId === undefined ||
+            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 === undefined ||
+            (Number.isSafeInteger(record.attempts) && record.attempts >= 0)) &&
+        (record.errorCommentPosted === undefined ||
+            typeof record.errorCommentPosted === 'boolean') &&
+        (record.error === undefined || typeof record.error === 'string'));
+}
 class FinalPublicationError extends Error {
 }
 const NO_REPLY_SENTINEL = '<no-reply/>';
@@ -64,8 +131,8 @@ function isNoReplySentinel(text) {
 }
 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);
 }
 function parseTriggerKind(metadata) {
     return metadata?.match(/^Trigger: ([\w-]+)\./m)?.[1];
@@ -79,13 +146,34 @@ function buildTriggerGuidance(reason) {
     }
     return `For ${reason}, output exactly ${NO_REPLY_SENTINEL} when a public reply is unnecessary.`;
 }
+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');
+}
 export class GithubChannel extends PollingChannelBase {
     octokit;
     botUsername = null;
     webOrigin = 'https://github.com';
     activeReactions = new Map();
     reactionsPendingRemoval = new Set();
+    pendingFinalDeliveryRetry;
+    pendingFinalDeliveryRetryAbort;
+    pendingFinalDeliveryRequestsActive = 0;
+    pendingFinalDeliveryRetryStopRequested = false;
     reasonFilter = null;
+    inboundRecoveryPending = true;
+    recoverableInboundTasks = 0;
+    activeInboundTaskIdsByMessage = new Map();
+    cancelledInboundTaskIds = new Set();
+    pendingCursorUpdatedAt;
+    inboundPersistenceBlocked = false;
     constructor(name, config, bridge, options) {
         config.blockStreaming = 'off';
         config.instructions = [
@@ -157,10 +245,42 @@ export class GithubChannel extends PollingChannelBase {
             process.stderr.write(`[Channel:${this.name}] warning: authenticated GitHub account "${this.botUsername}" is allowlisted but cannot trigger this channel; use a separate operator account.\n`);
         }
         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) {
+                process.stderr.write(`[Channel:${this.name}] pending GitHub delivery retry failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
+            }
+        })
+            .finally(() => {
+            if (this.pendingFinalDeliveryRetry === retry) {
+                this.pendingFinalDeliveryRetry = undefined;
+                this.pendingFinalDeliveryRetryAbort = undefined;
+            }
+        });
+        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`);
@@ -174,18 +294,15 @@ export class GithubChannel 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]) : undefined,
+        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,
@@ -201,6 +318,12 @@ export class GithubChannel extends PollingChannelBase {
         if (!threadMatch) {
             throw new Error(`[Channel:${this.name}] invalid threadId format: ${threadId}`);
         }
+        this.recordPublicationAudit({
+            ...auditBase,
+            at: new Date().toISOString(),
+            type: 'github_publication',
+            outcome: 'posting',
+        });
         try {
             const comment = await this.createIssueComment(chatId, threadId, fullText, 3, isDefiniteNoWriteGithubError);
             this.recordPublicationAudit({
@@ -221,10 +344,213 @@ export class GithubChannel 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]) : undefined,
+            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: 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}.`
+                    : undefined,
+            });
+            if (this.hasPostedPublicationAudit(record.id)) {
+                process.stderr.write(`[Channel:${this.name}] dropping pending GitHub delivery already recorded as posted: ${sanitizeLogText(record.id, 80)}\n`);
+                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);
+                // ponytail: GitHub has no createComment idempotency key without adding
+                // a public marker to the verbatim final body; marker-upsert if that
+                // contract changes.
+                this.recordPublicationAudit({
+                    ...auditBase,
+                    at: 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: 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) {
+            process.stderr.write(`[Channel:${this.name}] failed to update pending GitHub deliveries: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
+            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) {
+            process.stderr.write(`[Channel:${this.name}] failed to clean up inbound task: ${sanitizeLogText(cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr), 200)}\n`);
+        }
+    }
+    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') {
+                process.stderr.write(`[Channel:${this.name}] failed to read pending GitHub deliveries: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
+                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: 0o700 });
+        chmodSync(dir, 0o700);
+        const tmpPath = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmpPath, `${JSON.stringify(records)}\n`, {
+            encoding: 'utf-8',
+            mode: 0o600,
+        });
+        chmodSync(tmpPath, 0o600);
+        renameSync(tmpPath, path);
+        chmodSync(path, 0o600);
+    }
+    async createIssueComment(chatId, threadId, text, retries = 3, shouldRetry = () => true, signal) {
         if (!threadId) {
             throw new Error(`[Channel:${this.name}] createIssueComment requires a threadId`);
         }
@@ -234,12 +560,25 @@ export class GithubChannel 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;
     }
     /**
@@ -308,6 +647,18 @@ export class GithubChannel extends PollingChannelBase {
         });
     }
     async pollOnce() {
+        this.inboundPersistenceBlocked = false;
+        if (this.inboundRecoveryPending) {
+            try {
+                await this.recoverInboundTasks();
+            }
+            catch (err) {
+                process.stderr.write(`[Channel:${this.name}] inbound task recovery failed, will retry next poll: ${err}\n`);
+            }
+            finally {
+                this.inboundRecoveryPending = false;
+            }
+        }
         this.cursor.metaFloor ??= this.cursor.lastProcessedAt;
         const since = new Date(new Date(this.cursor.lastProcessedAt).getTime() - 1000).toISOString();
         const notifications = await this.githubApi(() => this.octokit.paginate(this.octokit.rest.activity.listNotificationsForAuthenticatedUser, { since, per_page: 100 }), 'listNotifications');
@@ -320,9 +671,12 @@ export class GithubChannel extends PollingChannelBase {
         // processing in a previous poll — skip them to prevent duplicates when
         // PUT /notifications' async mark fails to mark the thread read.
         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)
@@ -386,6 +740,19 @@ export class GithubChannel 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 = undefined;
+        }
     }
     async processCommentLane(ctx, onlyMentioned, directed = false) {
         const comments = await this.fetchNewComments(ctx);
@@ -415,7 +782,9 @@ export class GithubChannel 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;
             }
@@ -457,7 +826,9 @@ export class GithubChannel extends PollingChannelBase {
             isReplyToBot: false,
             metadata: `${this.buildMetadata(ctx.chatId, ctx.threadId, title)}\n${GITHUB_PUBLICATION_INSTRUCTIONS}\nTrigger: ${reason}.\n${buildTriggerGuidance(reason)}\n${details}`,
         };
-        await this.dispatchEnvelope(envelope, ctx.issueNumber);
+        await this.dispatchEnvelope(envelope, ctx.issueNumber, {
+            dispatchedEvents: [trigger.key],
+        });
         this.recordDispatched('dispatchedEvents', trigger.key);
     }
     async processAggregateLane(ctx) {
@@ -494,7 +865,9 @@ export class GithubChannel extends PollingChannelBase {
             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('/');
@@ -602,7 +975,9 @@ export class GithubChannel extends PollingChannelBase {
                 isReplyToBot: false,
                 metadata: this.buildRouteMetadata(ctx),
             };
-            await this.dispatchEnvelope(envelope, issueNumber);
+            await this.dispatchEnvelope(envelope, issueNumber, {
+                dispatchedBodies: [bodyKey],
+            });
             this.recordDispatchedBody(bodyKey);
         }
         catch (err) {
@@ -621,26 +996,266 @@ export class GithubChannel extends PollingChannelBase {
             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 = 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);
             process.stderr.write(`[Channel:${this.name}] handleInbound failed for ${envelope.messageId}: ${err}\n`);
-            if (!(err instanceof FinalPublicationError)) {
-                await this.postErrorComment(envelope.chatId, issueNumber);
+            if (err instanceof FinalPublicationError) {
+                if (this.cancelledInboundTaskIds.has(task.id)) {
+                    // already persisted as 'cancelled' by onTaskLifecycle
+                }
+                else if (this.hasPendingFinalDeliveryForTask(task)) {
+                    this.transitionInboundTask(task.id, 'reply_pending', {
+                        envelope: undefined,
+                        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);
+        }
+        // A base-class cancellation resolves handleInbound normally (the cancel is
+        // absorbed internally), so honour the terminal cancelled state captured
+        // above instead of removing the persisted record. Bookkeeping runs outside
+        // the try so a state read/write failure fails closed rather than being
+        // misclassified as a task failure that recovery would re-run.
+        if (cancelled)
+            return true;
+        if (this.hasPendingFinalDeliveryForTask(task)) {
+            this.transitionInboundTask(task.id, 'reply_pending', {
+                envelope: undefined,
+            });
+        }
+        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)
+            : 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: undefined,
+                });
+                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 = 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 new Set();
+            if (strict)
+                throw err;
+            return 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: 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;
+            process.stderr.write(`[Channel:${this.name}] failed to read GitHub inbound tasks: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
+            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: 0o700 });
+        chmodSync(dir, 0o700);
+        const tmpPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        writeFileSync(tmpPath, `${JSON.stringify(records)}\n`, {
+            encoding: 'utf-8',
+            mode: 0o600,
+        });
+        chmodSync(tmpPath, 0o600);
+        renameSync(tmpPath, path);
+        chmodSync(path, 0o600);
+    }
+    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: 0o700 });
             chmodSync(dir, 0o700);
             appendFileSync(path, `${JSON.stringify(record)}\n`, {
@@ -653,6 +1268,40 @@ export class GithubChannel extends PollingChannelBase {
             process.stderr.write(`[Channel:${this.name}] publication audit write failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
         }
     }
+    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: 0o700 });
+            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: 0o600 });
+        }
+        catch (err) {
+            process.stderr.write(`[Channel:${this.name}] legacy GitHub state migration failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
+        }
+    }
+    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)
@@ -671,12 +1320,16 @@ export class GithubChannel extends PollingChannelBase {
     buildRouteMetadata(ctx) {
         return `${this.buildMetadata(ctx.chatId, ctx.threadId, ctx.subjectTitle)}\n${GITHUB_PUBLICATION_INSTRUCTIONS}\nTrigger: ${ctx.reason}.\n${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;
                 // Octokit RequestError: { status, response?: { headers } }
@@ -699,11 +1352,30 @@ export class GithubChannel extends PollingChannelBase {
                     cooldown = 1000 * 2 ** (attempt - 1);
                 }
                 process.stderr.write(`[Channel:${this.name}] ${label} failed (attempt ${attempt}/${retries}, status=${e.status}), retrying in ${cooldown}ms: ${e.message}\n`);
-                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 = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+        });
+    }
     async markNotificationsAsRead(lastReadAt) {
         await this.githubApi(() => this.octokit.rest.activity.markNotificationsAsRead({
             last_read_at: lastReadAt,
@@ -718,9 +1390,11 @@ export class GithubChannel extends PollingChannelBase {
                 issue_number: issueNumber,
                 body: '⚠️ Failed to process this request. Please re-mention the bot to retry.',
             }), `postErrorComment(${chatId}#${issueNumber})`);
+            return true;
         }
         catch (err) {
             process.stderr.write(`[Channel:${this.name}] postErrorComment also failed for ${chatId}#${issueNumber}, user must re-mention manually: ${err}\n`);
+            return false;
         }
     }
 }