baxian 1.2.60 → 2.0.0

package/dist/platform/platform-poller.js

@@ -3,13 +3,37 @@ import { computeBackoffMs } from '../timing/backoff.js';
 import { computePollerHealth } from './poller-health.js';
 import { BRANCH_PREFIX } from '../shared/constants.js';
 import { repoIdentityKey } from '../shared/git-url.js';
+import { TASK_TERMINAL_STATUS_SET } from '../shared/constants.js';
 import { DriverOpError } from './git-driver.js';
 import { versionTimeOf } from './row-schema.js';
 import { CommentCursorStore } from './comment-cursor.js';
 import { VerdictEngine } from './verdict-engine.js';
-import { collectValidAcks } from './markers.js';
+import { collectValidAcks, rowBodyDigest } from './markers.js';
+import { createHash } from 'node:crypto';
 import { buildAckCarrierRows, feedbackEventTarget, scanCommentSourcesOnce } from './feedback.js';
 import { checkPrBinding } from './pr-binding.js';
+// TaskState 到轮询视图的唯一投影：poller 只看这些字段，其余任务状态一律不进轮询面。
+export function platformTaskView(task) {
+    return {
+        taskId: task.id,
+        terminal: TASK_TERMINAL_STATUS_SET.has(task.status),
+        reviewMode: task.reviewMode,
+        status: task.status,
+        inReview: task.status === 'review',
+        closedUnmergedAnchor: task.closedUnmergedAnchor !== undefined && task.closedUnmergedAnchor.cleared !== true,
+        ...(task.branch !== undefined ? { branch: task.branch } : {}),
+        ...(task.phase !== undefined ? { phase: task.phase } : {}),
+        ...(task.prNumber !== undefined ? { prNumber: task.prNumber } : {}),
+        ...(task.reviewHeadAnchorSha !== undefined ? { anchorSha: task.reviewHeadAnchorSha } : {}),
+        ...(task.passToken !== undefined ? { passToken: task.passToken } : {}),
+        ...(task.failToken !== undefined ? { failToken: task.failToken } : {}),
+        ...(task.signalToken !== undefined ? { signalToken: task.signalToken } : {}),
+        ...(task.baseBranch !== undefined ? { expectedBase: task.baseBranch } : {}),
+        ...(task.latestHeadSha !== undefined ? { latestHeadSha: task.latestHeadSha } : {}),
+        ...(task.replyActorId !== undefined ? { replyActorId: task.replyActorId } : {}),
+        ...(task.replyActorStatus !== undefined ? { replyActorStatus: task.replyActorStatus } : {}),
+    };
+}
 // 限流后必须停止请求并退避（GitHub 平台要求，持续触发 secondary limit 会招致封禁）：
 // 命中即短路该 entry 本周期剩余工作，退避窗口内整周期跳过，成功周期重置。
 // abort 携带此前已入列的全部失败：混合周期（如 ACCESS_DENIED → RATE_LIMIT）的真实
@@ -31,10 +55,17 @@ class CycleFailuresError extends Error {
         this.name = 'CycleFailuresError';
     }
 }
+class EntryRetiredError extends Error {
+    constructor() {
+        super('platform poller entry retired during reconciliation');
+        this.name = 'EntryRetiredError';
+    }
+}
 const RATE_LIMIT_BACKOFF_MIN_MS = 60_000;
 const RATE_LIMIT_BACKOFF_MAX_MS = 900_000;
 // 与 spec §8 base 快照同一时效纪律：projectView 连续失败 ≥3 周期后缓存默认分支视为缺失。
 const DEFAULT_BRANCH_STALE_CYCLES = 3;
+const ADOPTION_DEFERRAL_INTERVENTION_CYCLES = 3;
 export class PlatformPoller {
     opts;
     entries = [];
@@ -42,6 +73,7 @@ export class PlatformPoller {
     periodicRunner;
     isPolling = false;
     intervalMs;
+    lifecycleHook;
     now;
     constructor(opts) {
         this.opts = opts;
@@ -51,20 +83,89 @@ export class PlatformPoller {
         this.entries.push({
             ...init,
             repoKey: repoIdentityKey(init.repoUrl),
+            retired: false,
             status: { isPolling: false, consecutiveFailures: 0 },
             defaultBranchStale: 0,
             observedPr: new Map(),
+            conversationDigest: new Map(),
             deliveredVerdicts: new Map(),
             loggedUndated: new Set(),
             baseMismatch: new Map(),
+            adoptionDeferrals: new Map(),
         });
     }
-    remove(projectId) {
-        const i = this.entries.findIndex(e => e.projectId === projectId);
-        if (i === -1)
-            return false;
-        this.entries.splice(i, 1);
-        return true;
+    reconcile(wanted) {
+        const wantedByKey = this.indexWantedEntries(wanted);
+        this.retireUnwantedEntries(wantedByKey);
+        this.upsertWantedEntries(wantedByKey);
+        this.fireLifecycle();
+    }
+    indexWantedEntries(wanted) {
+        const wantedByKey = new Map();
+        for (const init of wanted) {
+            const key = repoIdentityKey(init.repoUrl);
+            if (!wantedByKey.has(key))
+                wantedByKey.set(key, init);
+        }
+        return wantedByKey;
+    }
+    retireUnwantedEntries(wantedByKey) {
+        for (let i = this.entries.length - 1; i >= 0; i--) {
+            if (!wantedByKey.has(this.entries[i].repoKey)) {
+                this.entries[i].retired = true;
+                this.entries.splice(i, 1);
+            }
+        }
+    }
+    upsertWantedEntries(wantedByKey) {
+        // Reusing repo-keyed entries keeps durable cursors and in-memory observations aligned across reloads.
+        const existingByKey = new Map(this.entries.map(e => [e.repoKey, e]));
+        for (const [key, init] of wantedByKey) {
+            const existing = existingByKey.get(key);
+            if (existing) {
+                if (existing.status.isPolling) {
+                    existing.pendingInit = { projectId: init.projectId, driver: init.driver };
+                }
+                else {
+                    this.applyEntryInit(existing, init);
+                }
+            }
+            else {
+                this.add(init);
+            }
+        }
+    }
+    applyEntryInit(entry, init) {
+        if (entry.retired)
+            return;
+        entry.projectId = init.projectId;
+        const samePreflight = entry.driver.preflightIdentity !== undefined
+            && init.driver.preflightIdentity !== undefined
+            ? entry.driver.preflightIdentity === init.driver.preflightIdentity
+            : entry.driver === init.driver;
+        if (!samePreflight)
+            entry.preflightPassed = undefined;
+        entry.driver = init.driver;
+    }
+    setLifecycleHook(fn) {
+        this.lifecycleHook = fn;
+    }
+    fireLifecycle() {
+        if (!this.lifecycleHook)
+            return;
+        try {
+            this.lifecycleHook();
+        }
+        catch (err) {
+            console.error('[PlatformPoller] lifecycle hook threw:', err);
+        }
+    }
+    // 超龄即视为缺失；纯缓存读，派发路径零网络调用。
+    defaultBranchSnapshot(repoKey) {
+        const entry = this.entries.find(e => e.repoKey === repoKey);
+        if (entry?.defaultBranch === undefined)
+            return undefined;
+        return entry.defaultBranchStale < DEFAULT_BRANCH_STALE_CYCLES ? entry.defaultBranch : undefined;
     }
     snapshots() {
         return this.entries.map(e => ({
@@ -98,6 +199,12 @@ export class PlatformPoller {
         }
         this.periodicRunner.start();
     }
+    // 热重载改 pollIntervalMs：只调整已在运行的 runner,不替一个从未 start 的 poller 启动
+    // （启动是 index 装配的职责）。未运行时仅记下新间隔,下次 start 生效。
+    reschedule(intervalMs) {
+        this.intervalMs = intervalMs;
+        this.periodicRunner?.reschedule(intervalMs);
+    }
     stop() {
         this.periodicRunner?.stop();
     }
@@ -110,11 +217,15 @@ export class PlatformPoller {
         }
         this.isPolling = true;
         try {
-            for (const entry of this.entries) {
+            for (const entry of [...this.entries]) {
+                if (entry.retired || !this.entries.includes(entry))
+                    continue;
                 try {
                     await this.pollOne(entry);
                 }
                 catch (e) {
+                    if (e instanceof EntryRetiredError)
+                        continue;
                     console.warn(`[PlatformPoller] entry ${entry.repoKey} failed:`, e instanceof Error ? e.message : e);
                 }
             }
@@ -124,11 +235,15 @@ export class PlatformPoller {
         }
     }
     async pollOne(entry) {
-        if (entry.rateLimit !== undefined && this.now() < entry.rateLimit.until)
+        this.assertEntryActive(entry);
+        if (entry.rateLimit !== undefined && this.now() < entry.rateLimit.until) {
+            entry.defaultBranchStale += 1;
             return;
+        }
         const startedAt = this.now();
         entry.status.isPolling = true;
         entry.status.lastPollStartedAt = new Date(startedAt).toISOString();
+        this.fireLifecycle();
         try {
             if (entry.cursor === undefined) {
                 const cursor = new CommentCursorStore(entry.statePath, entry.repoUrl);
@@ -145,6 +260,8 @@ export class PlatformPoller {
             entry.status.lastErrorClass = undefined;
         }
         catch (e) {
+            if (e instanceof EntryRetiredError)
+                return;
             if (e instanceof RateLimitAbort) {
                 // 不计凭据健康度（spec §5.3 要点）：退避顺延重试并在状态里如实标注 rate-limited。
                 const attempt = (entry.rateLimit?.attempt ?? 0) + 1;
@@ -169,9 +286,14 @@ export class PlatformPoller {
         }
         finally {
             entry.status.isPolling = false;
+            if (!entry.retired && entry.pendingInit !== undefined) {
+                this.applyEntryInit(entry, entry.pendingInit);
+                entry.pendingInit = undefined;
+            }
             const endedAt = this.now();
             entry.status.lastPollEndedAt = new Date(endedAt).toISOString();
             entry.status.lastPollDurationMs = endedAt - startedAt;
+            this.fireLifecycle();
         }
     }
     recordFailure(entry, message, errorClass) {
@@ -183,6 +305,8 @@ export class PlatformPoller {
     async pollCycle(entry) {
         const failures = [];
         const fail = (context, e) => {
+            if (e instanceof EntryRetiredError)
+                throw e;
             const failure = {
                 message: `${context}: ${e instanceof Error ? e.message : String(e)}`,
                 errorClass: e instanceof DriverOpError ? e.info.errorClass : undefined,
@@ -193,17 +317,29 @@ export class PlatformPoller {
         };
         try {
             await entry.cursor.flushIfDirty();
+            this.assertEntryActive(entry);
         }
         catch (e) {
             fail('cursor flush', e);
         }
         const tasks = await this.opts.tasks(entry.projectId);
+        this.assertEntryActive(entry);
         const byId = new Map(tasks.map(t => [t.taskId, t]));
         for (const gen of entry.cursor.generations()) {
-            const t = byId.get(gen);
-            if (t === undefined || t.terminal) {
+            let authoritative;
+            try {
+                authoritative = await this.opts.task(gen);
+                this.assertEntryActive(entry);
+            }
+            catch (e) {
+                fail(`read task ${gen}`, e);
+                continue;
+            }
+            if (authoritative === null || authoritative.terminal) {
                 try {
+                    this.assertEntryActive(entry);
                     await entry.cursor.dropGeneration(gen);
+                    this.assertEntryActive(entry);
                 }
                 catch (e) {
                     fail(`dropGeneration ${gen}`, e);
@@ -236,18 +372,54 @@ export class PlatformPoller {
             if (!activeKeys.has(key))
                 entry.deliveredVerdicts.delete(key);
         }
+        for (const key of entry.conversationDigest.keys()) {
+            if (!activeKeys.has(key))
+                entry.conversationDigest.delete(key);
+        }
         for (const key of entry.loggedUndated) {
             if (!activePrs.has(Number(key.split(':')[0])))
                 entry.loggedUndated.delete(key);
         }
+        // 首周期自证，失败进健康度周期重试；早退周期未刷新 projectView，须同步老化缓存。
+        if (entry.preflightPassed !== true && entry.driver.runPreflightSteps !== undefined) {
+            let steps;
+            try {
+                steps = await entry.driver.runPreflightSteps();
+                this.assertEntryActive(entry);
+            }
+            catch (e) {
+                entry.defaultBranchStale += 1;
+                fail('driver-preflight', e);
+                return failures;
+            }
+            const bad = steps.find(s => !s.ok);
+            if (bad !== undefined) {
+                entry.defaultBranchStale += 1;
+                fail(bad.step, new Error(bad.message));
+                return failures;
+            }
+        }
         let defaultBranch;
         try {
             const [row] = await entry.driver.runOp('projectView');
+            this.assertEntryActive(entry);
             if (row !== undefined && typeof row.defaultBranch === 'string') {
                 entry.defaultBranch = row.defaultBranch;
                 entry.defaultBranchStale = 0;
                 defaultBranch = row.defaultBranch;
             }
+            if (row !== undefined && entry.preflightPassed !== true && entry.driver.runPreflightSteps !== undefined) {
+                if (row.pushPermitted === false) {
+                    fail('preflight-push', new Error(`push permission missing for ${entry.repoUrl} — server merge/close requires write access`));
+                    return failures;
+                }
+                else {
+                    if (row.pushPermitted === undefined) {
+                        console.warn(`[PlatformPoller] ${entry.repoKey}: plugin did not report pushPermitted — write access cannot be asserted`);
+                    }
+                    entry.preflightPassed = true;
+                }
+            }
         }
         catch (e) {
             entry.defaultBranchStale += 1;
@@ -260,6 +432,7 @@ export class PlatformPoller {
                 ? entry.defaultBranch
                 : undefined);
         await this.pollListPrs(entry, tasks, byId, defaultBranch, fail, failures);
+        this.assertEntryActive(entry);
         for (const task of tasks) {
             if (task.terminal || task.prNumber === undefined)
                 continue;
@@ -268,6 +441,7 @@ export class PlatformPoller {
             if (task.closedUnmergedAnchor === true)
                 continue;
             await this.subPoll(entry, task, usableDefault, fail);
+            this.assertEntryActive(entry);
         }
         return failures;
     }
@@ -299,19 +473,56 @@ export class PlatformPoller {
                     return vt !== undefined && vt < prsCursor.watermarkTime;
                 });
             });
+            this.assertEntryActive(entry);
         }
         catch (e) {
             fail('listPrs', e);
             return;
         }
+        const listedPrRows = [...prRows];
+        const pendingByPr = new Map();
+        const activeDeferrals = new Set();
+        for (const pending of entry.cursor.pendingAdoptions()) {
+            let task;
+            try {
+                task = await this.opts.task(pending.taskId);
+                this.assertEntryActive(entry);
+                if (task === null || task.terminal || (task.prNumber !== undefined && task.prNumber !== pending.prNumber)) {
+                    await entry.cursor.clearAdoptionPending(pending.taskId, pending.prNumber);
+                    continue;
+                }
+                if (task.prNumber === pending.prNumber) {
+                    await entry.cursor.markAdoptionDelivered(pending.taskId, pending.prNumber);
+                    continue;
+                }
+                byId.set(task.taskId, task);
+                pendingByPr.set(pending.prNumber, pending.taskId);
+                if (prRows.some(row => row.prNumber === pending.prNumber))
+                    continue;
+                const [row] = await entry.driver.runOp('prView', { prNumber: pending.prNumber });
+                this.assertEntryActive(entry);
+                if (row !== undefined)
+                    prRows.push({ ...row, prNumber: pending.prNumber });
+            }
+            catch (e) {
+                activeDeferrals.add(pending.prNumber);
+                fail(`retry adoption pr#${pending.prNumber}`, e);
+            }
+        }
         const boundByPr = new Map();
         for (const t of tasks) {
             if (!t.terminal && t.prNumber !== undefined)
                 boundByPr.set(t.prNumber, t);
         }
         const failuresBefore = failures.length;
-        let deferredAdoptions = 0;
         const seenPrs = new Set();
+        const clearPending = async (prNumber) => {
+            const taskId = pendingByPr.get(prNumber);
+            if (taskId === undefined)
+                return;
+            await entry.cursor.clearAdoptionPending(taskId, prNumber);
+            pendingByPr.delete(prNumber);
+        };
         for (const row of prRows) {
             const prNumber = row.prNumber;
             seenPrs.add(prNumber);
@@ -322,10 +533,11 @@ export class PlatformPoller {
             };
             const boundTask = boundByPr.get(prNumber);
             if (boundTask !== undefined) {
+                await clearPending(prNumber);
                 // reopen 是显式 durable 观察：closed-unmerged 锚在 TaskState，主轮询见重开即合成（spec §6）。
                 if (boundTask.closedUnmergedAnchor === true && row.state === 'open') {
                     try {
-                        await this.emit(entry, 'pr.updated', { ...base, kind: 'reopened' });
+                        await this.emit(entry, 'pr.updated', { ...base, kind: 'reopened' }, boundTask.taskId);
                         entry.observedPr.delete(`${boundTask.taskId}:${prNumber}`);
                     }
                     catch (e) {
@@ -334,31 +546,48 @@ export class PlatformPoller {
                 }
                 continue;
             }
-            if (row.state !== 'open' || row.draft === true)
+            if (row.state !== 'open' || row.draft === true) {
+                await clearPending(prNumber);
                 continue;
-            if (!base.branch.startsWith(BRANCH_PREFIX))
+            }
+            if (!base.branch.startsWith(BRANCH_PREFIX)) {
+                await clearPending(prNumber);
                 continue;
+            }
             const task = byId.get(base.branch.slice(BRANCH_PREFIX.length));
-            if (task === undefined || task.terminal || task.prNumber !== undefined)
+            if (task === undefined || task.terminal || task.prNumber !== undefined) {
+                await clearPending(prNumber);
                 continue;
+            }
+            const pendingTaskId = pendingByPr.get(prNumber);
+            if (pendingTaskId !== undefined && pendingTaskId !== task.taskId)
+                await clearPending(prNumber);
             // 统一谓词 branch === task.branch：branch 缺失的任务视图无从核验绑定，收编一并 fail closed
             // （与子轮询 bindingCheck 对称——「无法核验」不是「匹配」）。
-            if (task.branch !== base.branch)
+            if (task.branch !== base.branch) {
+                await clearPending(prNumber);
                 continue;
+            }
             if (row.sourceProjectId === null || row.sourceProjectId === undefined
-                || row.sourceProjectId !== row.targetProjectId)
+                || row.sourceProjectId !== row.targetProjectId) {
+                await clearPending(prNumber);
                 continue;
+            }
             const target = String(row.targetBranch);
+            if (entry.cursor.isAdoptionDelivered(task.taskId, prNumber))
+                continue;
             try {
                 if (task.expectedBase !== undefined) {
-                    if (target !== task.expectedBase)
+                    if (target !== task.expectedBase) {
+                        await clearPending(prNumber);
                         continue;
+                    }
                 }
                 else {
                     if (defaultBranch === undefined) {
-                        // 收编推迟必须同时冻结水位：否则该 PR 被水位判「已处理」，projectView 恢复后
-                        // 它已落在停止页之外、永不再被扫描。
-                        deferredAdoptions += 1;
+                        await entry.cursor.markAdoptionPending(task.taskId, prNumber);
+                        pendingByPr.set(prNumber, task.taskId);
+                        activeDeferrals.add(prNumber);
                         continue;
                     }
                     if (target !== defaultBranch) {
@@ -368,17 +597,61 @@ export class PlatformPoller {
                         if (entry.baseMismatch.get(prNumber) !== fp) {
                             await this.emit(entry, 'human.intervention', {
                                 ...base, reason: 'base-mismatch', targetBranch: target, expectedBase: defaultBranch, taskId: task.taskId,
-                            });
+                            }, task.taskId);
                             entry.baseMismatch.set(prNumber, fp);
                         }
+                        await clearPending(prNumber);
                         continue;
                     }
                 }
+                const adoptionFingerprint = [
+                    task.taskId,
+                    task.status ?? '',
+                    task.phase ?? '',
+                    task.signalToken ?? '',
+                    task.reviewMode,
+                    base.branch,
+                    target,
+                    String(row.headSha),
+                ].join('\0');
+                const deferred = entry.adoptionDeferrals.get(prNumber);
+                if (deferred?.fingerprint === adoptionFingerprint) {
+                    deferred.cycles += 1;
+                    activeDeferrals.add(prNumber);
+                    if (!deferred.interventionDelivered
+                        && deferred.cycles >= ADOPTION_DEFERRAL_INTERVENTION_CYCLES) {
+                        await this.emit(entry, 'human.intervention', {
+                            ...base,
+                            reason: 'pr-adoption-deferred',
+                            taskId: task.taskId,
+                            status: task.status,
+                            phase: task.phase,
+                            cycles: deferred.cycles,
+                        }, task.taskId);
+                        deferred.interventionDelivered = true;
+                    }
+                    continue;
+                }
+                entry.adoptionDeferrals.delete(prNumber);
                 await this.emit(entry, 'pr.created', {
                     ...base, headSha: String(row.headSha), targetBranch: target,
                     ...(typeof row.prAuthorId === 'string' ? { prAuthorId: row.prAuthorId } : {}),
-                });
+                }, task.taskId);
+                const adoptedTask = await this.opts.task(task.taskId);
+                if (adoptedTask?.prNumber !== prNumber) {
+                    await entry.cursor.markAdoptionPending(task.taskId, prNumber);
+                    pendingByPr.set(prNumber, task.taskId);
+                    entry.adoptionDeferrals.set(prNumber, {
+                        fingerprint: adoptionFingerprint,
+                        cycles: 1,
+                        interventionDelivered: false,
+                    });
+                    activeDeferrals.add(prNumber);
+                    continue;
+                }
+                await entry.cursor.markAdoptionDelivered(task.taskId, prNumber);
                 entry.baseMismatch.delete(prNumber);
+                entry.adoptionDeferrals.delete(prNumber);
             }
             catch (e) {
                 fail(`adopt pr#${prNumber}`, e);
@@ -388,10 +661,15 @@ export class PlatformPoller {
             if (!seenPrs.has(pr))
                 entry.baseMismatch.delete(pr);
         }
-        if (failures.length > failuresBefore || deferredAdoptions > 0)
+        for (const pr of entry.adoptionDeferrals.keys()) {
+            if (!activeDeferrals.has(pr))
+                entry.adoptionDeferrals.delete(pr);
+        }
+        if (failures.length > failuresBefore)
             return;
         try {
-            await entry.cursor.commitListPrs(prRows, scanStartedAt - entry.driver.visibilityLagMs);
+            this.assertEntryActive(entry);
+            await entry.cursor.commitListPrs(listedPrRows, scanStartedAt - entry.driver.visibilityLagMs);
         }
         catch (e) {
             fail('listPrs cursor commit', e);
@@ -403,6 +681,7 @@ export class PlatformPoller {
         let prRow;
         try {
             [prRow] = await entry.driver.runOp('prView', { prNumber });
+            this.assertEntryActive(entry);
         }
         catch (e) {
             fail(`prView pr#${prNumber}`, e);
@@ -425,7 +704,7 @@ export class PlatformPoller {
                         taskId: task.taskId,
                         targetBranch: String(prRow.targetBranch),
                         ...(task.expectedBase !== undefined ? { expectedBase: task.expectedBase } : {}),
-                    });
+                    }, task.taskId);
                     observed.bindingMismatch = binding.mismatch;
                 }
                 catch (e) {
@@ -440,7 +719,7 @@ export class PlatformPoller {
             if (typeof prRow.mergedAt === 'string') {
                 if (observed.merged !== true) {
                     try {
-                        await this.emit(entry, 'pr.merged', base);
+                        await this.emit(entry, 'pr.merged', base, task.taskId);
                         observed.merged = true;
                     }
                     catch (e) {
@@ -450,7 +729,7 @@ export class PlatformPoller {
             }
             else if (observed.closedUnmerged !== true) {
                 try {
-                    await this.emit(entry, 'pr.updated', { ...base, kind: 'closed-unmerged' });
+                    await this.emit(entry, 'pr.updated', { ...base, kind: 'closed-unmerged' }, task.taskId);
                     observed.closedUnmerged = true;
                 }
                 catch (e) {
@@ -461,10 +740,14 @@ export class PlatformPoller {
             return;
         }
         observed.closedUnmerged = false;
+        if (task.reviewMode === 'server') {
+            this.engine.dropCandidate(task.taskId, prNumber);
+            return;
+        }
         const headSha = String(prRow.headSha);
         if (task.latestHeadSha !== undefined && headSha !== task.latestHeadSha.toLowerCase() && observed.pushSha !== headSha) {
             try {
-                await this.emit(entry, 'pr.updated', { ...base, kind: 'push', headSha });
+                await this.emit(entry, 'pr.updated', { ...base, kind: 'push', headSha }, task.taskId);
                 observed.pushSha = headSha;
             }
             catch (e) {
@@ -472,6 +755,7 @@ export class PlatformPoller {
             }
         }
         const scans = await this.scanCommentSources(entry, task, base, fail);
+        await this.noteConversationProjection(entry, task.taskId, obsKey, scans);
         const anchorSha = task.anchorSha?.toLowerCase();
         // 裁决资格门：head 偏离锚点只能走 push/recheck，旧锚令牌不得批准新 head；signalToken
         // 缺失**或空白**的事件会绕过既有 handler 的令牌比对（guard 是 truthy 双与，两个空值照样
@@ -505,6 +789,7 @@ export class PlatformPoller {
             // 评论源扫描最长可达分钟级，扫描期间 head/状态可被平台改写（TOCTOU）：emit 前以
             // 权威 prView 复核 open/!draft/绑定/锚点，失配清候选走 push/recheck，查询失败按瞬态重试。
             const [freshRow] = await entry.driver.runOp('prView', { prNumber });
+            this.assertEntryActive(entry);
             const freshEligible = freshRow !== undefined
                 && this.bindingCheck(task, freshRow, defaultBranch) === undefined
                 && freshRow.state === 'open' && freshRow.draft === false
@@ -515,6 +800,7 @@ export class PlatformPoller {
             }
             await this.emit(entry, 'review.submitted', {
                 ...base,
+                source: 'platform-poller',
                 action: decision.kind === 'pass' ? 'APPROVE' : 'REQUEST_CHANGES',
                 headSha: decision.anchorSha,
                 currentHeadSha: String(freshRow.headSha),
@@ -523,13 +809,49 @@ export class PlatformPoller {
                 verdictToken: decision.token,
                 verdictConflict: decision.conflict,
                 verdictCarrier: decision.carrier,
-            });
+            }, task.taskId);
             entry.deliveredVerdicts.set(obsKey, fp);
         }
         catch (e) {
             fail(`verdict pr#${prNumber}`, e);
         }
     }
+    // 全源成功才比对（失败源缺行会伪刷新两次）；回调失败不推进基线，下轮重试。
+    async noteConversationProjection(entry, taskId, obsKey, scans) {
+        const notify = this.opts.onConversationRevision;
+        if (notify === undefined)
+            return;
+        if (scans.length === 0 || scans.some(s => !s.ok))
+            return;
+        const h = createHash('sha256');
+        for (const scan of [...scans].sort((a, b) => a.key.localeCompare(b.key))) {
+            // 源未承诺稳定行序：按行身份规范化后再散列，重排不产生伪 revision。
+            const rows = [...scan.rows].sort((a, b) => {
+                const ai = String(a.id);
+                const bi = String(b.id);
+                if (ai !== bi)
+                    return ai < bi ? -1 : 1;
+                const ad = rowBodyDigest(a);
+                const bd = rowBodyDigest(b);
+                return ad < bd ? -1 : ad > bd ? 1 : 0;
+            });
+            for (const row of rows) {
+                // versionTime 入摘要：正文相同但 updatedAt 变化会改变时间线排序（进而改变分轮），
+                // 不计入就永远不推进展示 revision。
+                h.update(`${scan.key}:${String(row.id)}:${rowBodyDigest(row)}:${String(row.reviewState ?? '')}:${String(versionTimeOf(row) ?? '')}\n`);
+            }
+        }
+        const digest = h.digest('hex');
+        if (entry.conversationDigest.get(obsKey) === digest)
+            return;
+        try {
+            await notify(taskId);
+            entry.conversationDigest.set(obsKey, digest);
+        }
+        catch (e) {
+            console.warn('[PlatformPoller] onConversationRevision failed:', e instanceof Error ? e.message : e);
+        }
+    }
     async scanCommentSources(entry, task, base, fail) {
         const scans = await scanCommentSourcesOnce(entry.driver, base.prNumber, this.now, (key, error) => fail(`listComments[${key}] pr#${base.prNumber}`, error));
         // ack 完成集跨源计算一次：issue 类顶层 ack 可指向任意源的 revision，threaded 隶属
@@ -569,7 +891,7 @@ export class PlatformPoller {
                         ...(scan.sourceClass === 'threaded' && row.discussionId !== null && row.discussionId !== undefined
                             ? { reviewCommentReply: true }
                             : {}),
-                    });
+                    }, task.taskId);
                     await entry.cursor.markDelivered(task.taskId, base.prNumber, scan.key, id, digest);
                 }
                 catch (e) {
@@ -579,6 +901,7 @@ export class PlatformPoller {
             }
             if (delivered) {
                 try {
+                    this.assertEntryActive(entry);
                     await entry.cursor.commitSource(task.taskId, base.prNumber, scan.key, scan.rows, cutoff);
                 }
                 catch (e) {
@@ -598,8 +921,13 @@ export class PlatformPoller {
         }
         return scans;
     }
-    async emit(entry, type, data) {
-        await this.opts.onEvent(entry.projectId, { type, repo: entry.repoKey, data });
+    async emit(entry, type, data, taskId) {
+        this.assertEntryActive(entry);
+        await this.opts.onEvent(entry.projectId, { type, repo: entry.repoKey, data, taskId });
+    }
+    assertEntryActive(entry) {
+        if (entry.retired || !this.entries.includes(entry))
+            throw new EntryRetiredError();
     }
 }
 //# sourceMappingURL=platform-poller.js.map