baxian 1.1.0 → 1.2.1

package/dist/event/handlers.js

@@ -8,7 +8,7 @@ function validHeadSha(value) {
 // Re-establish the develop-phase watcher after a handler-side rejection so the same
 // task can consume a corrected emit (same token) without a server restart.
 async function reArmDevelopWatcher(manager, task, agentId) {
-    const kinds = task.phase === 'code' ? ['pr-created'] : ['spec-created', 'pr-created'];
+    const kinds = task.phase === 'code' ? ['pr-created'] : ['spec-done', 'pr-created'];
     await manager.setupPhaseSignal(task.id, agentId, kinds);
 }
 async function emitIntervention(bus, projectId, agentId, taskId, data) {
@@ -157,10 +157,8 @@ export function registerEventHandlers(bus, manager) {
         // transition only needs prNumber to wire task→PR; prUrl is derivable from
         // repo+number; headSha lands via the next pr.updated push event.
         //
-        // spec phase 完全由 signal 协议（spec.ready / spec.review.submitted / spec.fix.submitted）
-        // 驱动；spec doc 的 PR push 也会触发 pr.created/updated，poller 不应越过 signal 协议派
-        // QA review。否则 QA 在 spec-review 槽位上跑 pr-review 流程，再 gh pr review --approve
-        // → review.submitted → post-approve dispatch，实际代码还没写。
+        // spec phase 由 server 评审链（server.spec.* handlers）驱动；poller 不应越过它派 QA review，
+        // 否则 QA 在 spec-review 槽位上跑 pr-review 流程，gh pr review --approve 会误触 post-approve。
         {
             const taskNow = await manager.getTask(event.taskId);
             if (taskNow?.phase === 'spec') {
@@ -334,16 +332,16 @@ export function registerEventHandlers(bus, manager) {
         if (!event.taskId || !event.agentId)
             return;
         // Server tasks review via the exchange protocol — a poller-observed sync on
-        // the published PR must not drag them into legacy QA review (PR #288).
+        // the published PR must not drag them into legacy QA review.
         // pr.merged stays open: external merges of a ready PR finish through it.
         if (await isServerModeTask(manager, event.taskId))
             return;
         const eventPrNumber = event.data.prNumber;
         const eventPrUrl = event.data.prUrl;
         const eventKind = event.data.kind;
-        // spec phase 由 signal 协议驱动；spec doc 的 push / spec-review 留下的 PR comment 都不应
-        // 进入 code-review 流程（避免派 QA recheck → gh pr review --approve → 误派 post-approve）。
-        // pr-merge-ready 是 dev 自己内部状态推进，不受 phase gate 限制。
+        // spec phase 由 server 评审链驱动；spec doc 的 push/comment 不应进入 code-review 流程
+        // （避免 QA recheck → gh pr review --approve → 误派 post-approve）。
+        // pr-merge-ready 是 dev 内部状态推进，不受 phase gate 限制。
         if (eventKind !== 'pr-merge-ready') {
             const taskNow = await manager.getTask(event.taskId);
             if (taskNow?.phase === 'spec') {
@@ -416,7 +414,7 @@ export function registerEventHandlers(bus, manager) {
             // operator. merge:'auto' no longer merges here; it decides what the confirm
             // endpoint executes (server merges on confirm vs human merges by hand).
             // Persist the post-approve head: confirm's merge guards on it so a push
-            // landing inside the gate window can never be merged blind (PR #288).
+            // landing inside the gate window can never be merged blind.
             const readied = await manager.transitionTaskStatus(freshTask.id, 'merge-ready', { fromStatus: ['approved'] }, { latestHeadSha: freshCompletion.approvedHeadSha });
             if (readied) {
                 await manager.clearPostApproveCompletionIfMatches(freshTask.id, signalToken);
@@ -541,10 +539,9 @@ export function registerEventHandlers(bus, manager) {
         }
         // Any push once the task is already past initial dispatch (review/fixing/approved)
         // is a re-look → 'recheck'. The recheck prompt is phrased neutrally ("re-check the
-        // new commits and any prior feedback"), so it no longer makes the false "dev
-        // addressed your prior changes-requested" claim that originally motivated narrowing
-        // this — and keeping 'recheck' for previousStatus='review' preserves the recheck
-        // framing for a push DURING a recheck (Codex review: don't downgrade mid-recheck pushes).
+        // new commits and any prior feedback"), so it never falsely claims "dev addressed
+        // your prior changes-requested"; keeping 'recheck' for previousStatus='review'
+        // preserves the recheck framing for a push DURING a recheck (don't downgrade it).
         const qaPhase = previousStatus === 'fixing' || previousStatus === 'review'
             || previousStatus === 'approved' || previousStatus === 'merge-ready'
             ? 'recheck'
@@ -577,7 +574,7 @@ export function registerEventHandlers(bus, manager) {
             // No armed watcher → a same-identity verdict would have no consumer.
             console.warn(`[EventHandler] pr.updated verdict watcher failed to arm for task=${transitioned.id} (${qaPhase}); rolling back recheck dispatch`);
             if (previousStatus === 'in_progress' || previousStatus === 'fixing') {
-                // Full rollback: the dev's prior-phase prompt (spec-created/pr-created or pr-fixed) used the
+                // Full rollback: the dev's prior-phase prompt (spec-done/pr-created or pr-fixed) used the
                 // pre-rotation token; restore status+token+anchor and re-arm so its already-emitted signal
                 // isn't stranded by the token rotation.
                 await manager.rollbackVerdictArmFailure(transitioned.id, {
@@ -680,7 +677,7 @@ export function registerEventHandlers(bus, manager) {
         // max_rounds included so manual mark-complete (and an externally-merged
         // max_rounds PR the poller detects) transitions to merged + runs cleanup.
         // ready included for server-mode afterDone:'pr' tasks whose managed PR is
-        // merged directly on GitHub instead of via baxian's Confirm (PR #288).
+        // merged directly on GitHub instead of via baxian's Confirm.
         { fromStatus: ['in_progress', 'fixing', 'review', 'approved', 'merge-ready', 'ready', 'max_rounds'] }, prPatch);
         if (!result)
             return;
@@ -746,10 +743,9 @@ export function registerEventHandlers(bus, manager) {
                 }
             }
         }
-        // spec phase（非 terminal）由 signal 协议（spec.review.submitted）驱动 verdict；GitHub
-        // PR review 不应改 task.status。QA 在 spec-review 槽位上若错走 gh pr review --approve，
-        // 这里早退避免把 status 推到 approved + 派 dev post-approve。terminal 状态已在前面兜底
-        // 释放，此处只屏蔽 active spec 路径。
+        // spec phase（非 terminal）由 server 评审链（server.spec.review.submitted）驱动 verdict；
+        // GitHub PR review 不应改 task.status，早退避免误推 approved + 派 dev post-approve。
+        // terminal 状态已在前面兜底释放，此处只屏蔽 active spec 路径。
         if (task.phase === 'spec') {
             console.warn(`[EventHandler] review.submitted (action=${action}) ignored for task ${task.id}: task in spec phase`);
             return;
@@ -1045,7 +1041,7 @@ export function registerEventHandlers(bus, manager) {
             // Set up the pr-fixed completion watcher BEFORE the prompt. rotateAndSetupPhaseSignal
             // rotates the per-pass token atomically; continueSession then reads that token and
             // embeds it in the fix prompt, so the dev's pr-fixed signal advances fixing→review
-            // even when the round produced no push (the task-060 deadlock).
+            // even when the round produced no push.
             const { armed } = await manager.rotateAndSetupPhaseSignal(transitioned.id, transitioned.agentId, 'pr-fixed');
             if (!armed) {
                 // pr-fixed watcher didn't arm → the fix completion signal (esp. the no-push case) would have
@@ -1085,225 +1081,9 @@ export function registerEventHandlers(bus, manager) {
             }
         }
     });
-    bus.on('spec.ready', async (event) => {
-        if (!event.taskId)
-            return;
-        const task = await manager.getTask(event.taskId);
-        if (!task)
-            return;
-        // Freshness gate: 拒迟到 / scrollback 复活的 stale spec-created signal。
-        // 期望 task 仍在 pre-spec 阶段 (phase undefined, status in_progress) 且 token 匹配。
-        const eventToken = event.data?.token;
-        const stale = task.phase !== undefined
-            || task.status !== 'in_progress'
-            || !eventToken
-            || eventToken !== task.signalToken;
-        if (stale) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-created-event-stale',
-                taskPhase: task.phase ?? null,
-                taskStatus: task.status,
-            });
-            return;
-        }
-        try {
-            await manager.dispatchSpecReviewToQa(event.taskId);
-        }
-        catch (err) {
-            console.error(`[EventHandler] spec.ready dispatchSpecReviewToQa(${event.taskId}) failed:`, err);
-            await emitIntervention(bus, event.projectId, event.agentId ?? '', event.taskId, {
-                phase: 'spec-created-dispatch-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    });
-    bus.on('spec.review.submitted', async (event) => {
-        if (!event.taskId)
-            return;
-        const task = await manager.getTask(event.taskId);
-        if (!task)
-            return;
-        // Freshness gate: stale signal would inject old findings into a code-phase session.
-        const eventToken = event.data?.token;
-        const stale = task.phase !== 'spec'
-            || task.status !== 'review'
-            || !eventToken
-            || eventToken !== task.signalToken;
-        if (stale) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-review-event-stale',
-                taskPhase: task.phase ?? null,
-                taskStatus: task.status,
-            });
-            return;
-        }
-        const round = task.specReviewRound ?? 1;
-        // Verdict comes from the signal kind directly — no findings.json read for
-        // the verdict bit. findings.json is still read later (during spec-fix
-        // dispatch) for the issue list, but its schema no longer carries a verdict.
-        const signalKind = event.data?.kind;
-        if (signalKind === 'spec-approved') {
-            try {
-                await manager.transitionToCodePhase(task.id);
-            }
-            catch (err) {
-                console.error(`[EventHandler] spec.review approve transitionToCodePhase(${task.id}) failed:`, err);
-                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                    phase: 'spec-review-approve-transition-failed',
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            return;
-        }
-        if (signalKind !== 'spec-changes-requested') {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-review-unknown-verdict-signal',
-                round,
-                signalKind: signalKind ?? null,
-            });
-            return;
-        }
-        // changes-requested path: load findings.json for the issue list (verdict
-        // already known from the signal kind above).
-        const fileName = `round-${round}-findings.json`;
-        let raw = null;
-        try {
-            raw = await manager.readSpecReviewFile(event.taskId, fileName);
-        }
-        catch (err) {
-            console.error(`[EventHandler] spec.review.submitted readSpecReviewFile(${event.taskId}) failed:`, err);
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-review-findings-read-failed',
-                round,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return;
-        }
-        if (raw === null) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-review-findings-missing',
-                round,
-                fileName,
-            });
-            return;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch (err) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-review-findings-invalid-json',
-                round,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return;
-        }
-        // Round mismatch ⇒ QA wrote wrong-round content into current findings file.
-        if (typeof parsed.round !== 'number' || parsed.round !== round) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-review-findings-round-mismatch',
-                round,
-                parsedRound: parsed.round ?? null,
-            });
-            return;
-        }
-        const cap = manager.getConfig().review.rounds;
-        if (round >= cap) {
-            const result = await manager.transitionTaskStatus(event.taskId, 'max_rounds', { fromStatus: ['review'] });
-            if (!result)
-                return;
-            const { task: transitioned } = result;
-            manager.stopSpecSignalWatcher(transitioned.id);
-            // release 失败时 binding 残留 → 后续 acquire 会拒；emit intervention 让 stale binding 可见。
-            // spec max_rounds 同样暂停为 active 态：清掉已成功释放（解绑）的 agent 引用，否则该已释放
-            // agent 之后因 tmux/recovery 失败会经 failTasksForAgent 把这个暂停 task 误标 failed。仅当释放
-            // 成功（确已解绑）才清——若仍 held/bound 则保留引用，让其故障正常归因到本 task。
-            const clearIds = {};
-            if (transitioned.qaAgentId) {
-                const qaReleased = await manager
-                    .releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle')
-                    .catch(() => false);
-                if (qaReleased) {
-                    clearIds.qaAgentId = undefined;
-                }
-                else {
-                    await emitIntervention(bus, transitioned.projectId, transitioned.qaAgentId, transitioned.id, {
-                        phase: 'spec-review-max-rounds-qa-release-failed',
-                        qaAgentId: transitioned.qaAgentId,
-                    });
-                }
-            }
-            if (transitioned.agentId) {
-                const devReleased = await manager
-                    .releaseAgentForTask(transitioned.agentId, transitioned.id, 'idle')
-                    .catch(() => false);
-                if (devReleased) {
-                    clearIds.agentId = undefined;
-                }
-                else {
-                    await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
-                        phase: 'spec-review-max-rounds-dev-release-failed',
-                        devAgentId: transitioned.agentId,
-                    });
-                }
-            }
-            if ('qaAgentId' in clearIds || 'agentId' in clearIds) {
-                await manager.updateTask(transitioned.id, clearIds)
-                    .catch(err => console.error(`[EventHandler] spec max_rounds clear agent ids(${transitioned.id}) failed:`, err));
-            }
-            await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
-                phase: 'spec-review-max-rounds',
-                round,
-                cap,
-            });
-            return;
-        }
-        // changes-requested 必须有非空 findings — 提前 fail-loud。
-        if (!Array.isArray(parsed.findings) || parsed.findings.length === 0) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-review-findings-invalid-shape',
-                round,
-                findingsType: Array.isArray(parsed.findings) ? 'empty-array' : typeof parsed.findings,
-            });
-            return;
-        }
-        // 每条 finding 必须有唯一非空 id — coverage 校验依赖它。fail-closed。
-        const findingsArr = parsed.findings;
-        const idSet = new Set();
-        for (const f of findingsArr) {
-            const id = f?.id;
-            if (typeof id !== 'string' || id.length === 0) {
-                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                    phase: 'spec-review-findings-missing-id',
-                    round,
-                });
-                return;
-            }
-            if (idSet.has(id)) {
-                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                    phase: 'spec-review-findings-duplicate-id',
-                    round,
-                    duplicateId: id,
-                });
-                return;
-            }
-            idSet.add(id);
-        }
-        try {
-            await manager.dispatchSpecFixToDev(task.id, raw);
-        }
-        catch (err) {
-            console.error(`[EventHandler] spec.review dispatchSpecFixToDev(${task.id}) failed:`, err);
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-dispatch-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    });
     // Dev emitted pr-fixed: it claims the fixing round is done. Verify on GitHub
     // before advancing (option C) — a new commit OR a reply to the findings means
-    // real work; neither means a no-op claim (the task-060 lie). Every GitHub read
+    // real work; neither means a no-op claim. Every GitHub read
     // fails closed: a verification we can't complete must NOT be read as "no-op".
     bus.on('pr.fix.submitted', async (event) => {
         if (!event.taskId || !event.agentId)
@@ -1407,206 +1187,5 @@ export function registerEventHandlers(bus, manager) {
             });
         }
     });
-    bus.on('spec.fix.submitted', async (event) => {
-        if (!event.taskId)
-            return;
-        const task = await manager.getTask(event.taskId);
-        if (!task)
-            return;
-        // Freshness gate: stale signal may re-trigger dispatch after spec phase exit.
-        const eventToken = event.data?.token;
-        const stale = task.phase !== 'spec'
-            || task.status !== 'fixing'
-            || !eventToken
-            || eventToken !== task.signalToken;
-        if (stale) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-event-stale',
-                taskPhase: task.phase ?? null,
-                taskStatus: task.status,
-            });
-            return;
-        }
-        const round = task.specReviewRound ?? 1;
-        const fileName = `round-${round}-response.json`;
-        let raw = null;
-        try {
-            raw = await manager.readSpecReviewFile(event.taskId, fileName);
-        }
-        catch (err) {
-            console.error(`[EventHandler] spec.fix.submitted readSpecReviewFile(${event.taskId}) failed:`, err);
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-response-read-failed',
-                round,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return;
-        }
-        if (raw === null) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-response-missing',
-                round,
-                fileName,
-            });
-            return;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch (err) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-response-invalid-json',
-                round,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return;
-        }
-        if (typeof parsed.round !== 'number' || parsed.round !== round) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-response-round-mismatch',
-                round,
-                parsedRound: parsed.round ?? null,
-            });
-            return;
-        }
-        if (!Array.isArray(parsed.responses)) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-response-invalid-shape',
-                round,
-            });
-            return;
-        }
-        const responses = parsed.responses;
-        if (responses.length === 0) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-response-empty',
-                round,
-            });
-            return;
-        }
-        for (const r of responses) {
-            if (r?.action !== 'fix' && r?.action !== 'reject') {
-                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                    phase: 'spec-fix-response-invalid-action',
-                    round,
-                    action: r?.action ?? null,
-                });
-                return;
-            }
-        }
-        // Coverage check: response must cover every finding.id; all branches fail-closed
-        // (read/parse/round-mismatch all emit + return — fail-open would let all-reject sneak into code phase).
-        let findingsRaw;
-        try {
-            findingsRaw = await manager.readSpecReviewFile(event.taskId, `round-${round}-findings.json`);
-        }
-        catch (err) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-coverage-findings-read-failed',
-                round,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return;
-        }
-        if (findingsRaw === null) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-coverage-findings-missing',
-                round,
-            });
-            return;
-        }
-        let findingsParsed;
-        try {
-            findingsParsed = JSON.parse(findingsRaw);
-        }
-        catch (err) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-coverage-findings-invalid-json',
-                round,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return;
-        }
-        if (typeof findingsParsed.round !== 'number' || findingsParsed.round !== round) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-coverage-findings-round-mismatch',
-                round,
-                parsedRound: findingsParsed.round ?? null,
-            });
-            return;
-        }
-        // 独立 fail-closed schema 校验 — 上一阶段的校验对本 handler 不可信。
-        if (!Array.isArray(findingsParsed.findings) || findingsParsed.findings.length === 0) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-coverage-findings-invalid-shape',
-                round,
-                findingsType: Array.isArray(findingsParsed.findings)
-                    ? 'empty-array'
-                    : typeof findingsParsed.findings,
-            });
-            return;
-        }
-        const findingIdsList = [];
-        for (const f of findingsParsed.findings) {
-            const id = f?.id;
-            if (typeof id !== 'string' || id.length === 0) {
-                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                    phase: 'spec-fix-coverage-findings-missing-id',
-                    round,
-                });
-                return;
-            }
-            if (findingIdsList.includes(id)) {
-                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                    phase: 'spec-fix-coverage-findings-duplicate-id',
-                    round,
-                    duplicateId: id,
-                });
-                return;
-            }
-            findingIdsList.push(id);
-        }
-        const findingIds = new Set(findingIdsList);
-        const responseIds = new Set(responses
-            .map(r => r?.findingId)
-            .filter((id) => typeof id === 'string'));
-        const missing = [...findingIds].filter(id => !responseIds.has(id));
-        const unknown = [...responseIds].filter(id => !findingIds.has(id));
-        if (missing.length > 0 || unknown.length > 0) {
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-response-coverage-mismatch',
-                round,
-                missingFindingIds: missing,
-                unknownFindingIds: unknown,
-            });
-            return;
-        }
-        const hasAnyFix = responses.some(r => r.action === 'fix');
-        if (!hasAnyFix) {
-            // 全 reject → dev 直接进 code phase；不再 qa review。
-            try {
-                await manager.transitionToCodePhase(task.id);
-            }
-            catch (err) {
-                console.error(`[EventHandler] spec.fix all-reject transitionToCodePhase(${task.id}) failed:`, err);
-                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                    phase: 'spec-fix-all-reject-transition-failed',
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            return;
-        }
-        try {
-            await manager.dispatchSpecReviewToQa(task.id);
-        }
-        catch (err) {
-            console.error(`[EventHandler] spec.fix dispatchSpecReviewToQa(${task.id}) failed:`, err);
-            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
-                phase: 'spec-fix-redispatch-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    });
 }
 //# sourceMappingURL=handlers.js.map