baxian 1.0.0 → 1.0.2

package/dist/agent/manager.js

@@ -2,13 +2,13 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createSignalToken } from './phase-signal.js';
-import { BRANCH_PREFIX, PHASE_EXPECTED_STATUS, PHASE_REQUIRES_AGENT_BOUND_TO_TASK, TASK_TERMINAL_STATUSES as TERMINAL_STATUSES, } from '../shared/index.js';
+import { BRANCH_PREFIX, PHASE_EXPECTED_STATUS, PHASE_REQUIRES_AGENT_BOUND_TO_TASK, TASK_TERMINAL_STATUSES as TERMINAL_STATUSES, TASK_ACTIVE_STATUS_SET as ACTIVE_TASK_STATUSES, } from '../shared/index.js';
 import { AGENT_STORE_NOOP } from '../state/agent-store.js';
 import { PostApproveStore } from '../state/post-approve-store.js';
 import { SkillRegistry } from '../skill/registry.js';
-import { createRunner, LocalRunner, shellQuote } from './runner.js';
+import { createRunner, LocalRunner, shellQuote, resolveAgentHost } from './runner.js';
 import { imageFilename, agentHostPath, writeImageToHost } from './image-input.js';
-import { TmuxManager, ReplNotReadyError, detectStartupDialog, detectRuntimeMenu, detectReplActiveBusy, hasReplReadyAnchor, hasReplProcTitle, } from './tmux.js';
+import { TmuxManager, ReplNotReadyError, detectStartupDialog, detectRuntimeMenu, detectReplActiveBusy, hasRuntimeReadyView, hasReplProcTitle, } from './tmux.js';
 import { WorktreeManager } from './worktree.js';
 import { RepoStore, createRepoStoreCache } from './repo-store.js';
 import { PhaseSignalWatcher } from './phase-signal-watcher.js';
@@ -72,7 +72,6 @@ function agentRuntimeKindFor(agent) {
 }
 const DEFAULT_DISPATCH_ACK_TIMEOUT_MS = 30_000;
 const DEFAULT_DISPATCH_SETTLE_TIMEOUT_MS = 3_000;
-const ACTIVE_TASK_STATUSES = new Set(['in_progress', 'review', 'fixing', 'approved', 'merge-ready']);
 // Dev-facing deliverable phases that weave the task's uploaded image paths into the prompt (task-055).
 const IMAGE_DISPATCH_PHASES = new Set(['develop', 'code', 'fix', 'spec-fix']);
 export function canDispatchWithBinding(binding) {
@@ -134,6 +133,10 @@ export class AgentManager {
     postMergeBranchTimeoutMs = 10_000;
     // taskIds with in-flight manual review — second concurrent POST gets 409.
     manualReviewInFlight = new Set();
+    // taskIds with an in-flight mark-complete (slow external `gh pr merge`). While set, the
+    // task is being merged — Cancel / Call review / Continue must refuse so they can't act on
+    // the same max_rounds snapshot and interleave with the irreversible merge.
+    markCompleteInFlight = new Set();
     // agentIds with in-flight DELETE — 第二个 DELETE 撞 awaiting_human stale-lock takeover 路径会
     // 把第一个 DELETE 持有的占位也当 stale 接管，导致并发 cleanupRemovedAgentRuntime。
     deletionInFlight = new Set();
@@ -1333,9 +1336,8 @@ export class AgentManager {
             const tasks = await this.taskStore.list({});
             const out = [];
             for (const t of tasks) {
-                const active = ['in_progress', 'review', 'fixing', 'approved', 'merge-ready'];
                 const bound = t.agentId === agentId || t.qaAgentId === agentId;
-                if (active.includes(t.status) && bound) {
+                if (ACTIVE_TASK_STATUSES.has(t.status) && bound) {
                     t.status = 'failed';
                     t.updatedAt = new Date().toISOString();
                     await this.taskStore.set(t);
@@ -1882,13 +1884,14 @@ export class AgentManager {
         if (this.runnerFactory) {
             return this.runnerFactory(agent);
         }
-        return createRunner(agent.mode, agent.host);
+        return createRunner(agent.mode, resolveAgentHost(this.config.host, agent.host));
     }
     createRepoStore(agent, project, runner) {
+        const host = resolveAgentHost(this.config.host, agent.host);
         if (this.repoStoreFactory) {
-            return this.repoStoreFactory(runner, project.repo, agent.mode, agent.host, this.repoCache);
+            return this.repoStoreFactory(runner, project.repo, agent.mode, host, this.repoCache);
         }
-        return new RepoStore(runner, project.repo, agent.mode, agent.host, this.repoCache);
+        return new RepoStore(runner, project.repo, agent.mode, host, this.repoCache);
     }
     async ensureWorkdir(agent, project, runner) {
         if (agent.workdir)
@@ -3001,6 +3004,39 @@ export class AgentManager {
                 // 处理 Held：与 resumeAgent 共用 shouldReleaseHeldBinding 规则（task terminal/无 task /
                 // turn-completed phase → 同步清 binding；task active 且 phase 不在 completed 集合 → 保留 binding）。
                 const boundTask = state.taskId ? await this.taskStore.get(state.taskId) : null;
+                if (state.taskId
+                    && boundTask?.id === state.taskId
+                    && boundTask.status === 'merged'
+                    && boundTask.prNumber != null
+                    && boundTask.branch
+                    && !state.creationToken
+                    && state.status !== 'awaiting_human') {
+                    try {
+                        await this.agentStore.update(state.id, (latest) => {
+                            if (!latest || latest.taskId !== boundTask.id)
+                                return AGENT_STORE_NOOP;
+                            if (latest.creationToken || latest.status === 'awaiting_human')
+                                return AGENT_STORE_NOOP;
+                            return { ...latest, paneId: result.paneId, updatedAt: new Date().toISOString() };
+                        });
+                        const recovered = await this.agentStore.get(state.id);
+                        if (recovered?.taskId !== boundTask.id
+                            || recovered.paneId !== result.paneId
+                            || recovered.creationToken
+                            || recovered.status === 'awaiting_human') {
+                            continue;
+                        }
+                        await this.dispatchPostMergeCleanup(state.id, {
+                            prNumber: boundTask.prNumber,
+                            taskId: boundTask.id,
+                            branch: boundTask.branch,
+                        });
+                        continue;
+                    }
+                    catch (cleanupErr) {
+                        console.warn(`[recover] dispatchPostMergeCleanup(${state.id}, ${boundTask.id}) failed:`, cleanupErr);
+                    }
+                }
                 const shouldReleaseBinding = shouldReleaseHeldBinding(state, boundTask);
                 // 释放 binding 时同步清 worktree（与 resumeAgent 一致）——否则跨重启恢复后
                 // worktreePath 在下面 update 中被丢弃，磁盘上的 worktree 永远无人回收。
@@ -3206,6 +3242,12 @@ export class AgentManager {
                 throw new ApiError(404, 'Task not found');
             if (TERMINAL_STATUSES.includes(task.status))
                 return task;
+            // A mark-complete merge is mid-flight (task is merge-ready, PR being merged) — refuse
+            // to cancel so the merge can't land while the task is flipped to cancelled (which would
+            // make pr.merged a no-op and skip cleanup). Checked under the lock to close the window.
+            if (this.markCompleteInFlight.has(taskId)) {
+                throw new ApiError(409, `Task ${taskId} is being completed (merge in progress); try again shortly`);
+            }
             if (task.agentId)
                 devToRelease = task.agentId;
             if (task.qaAgentId)
@@ -3292,9 +3334,22 @@ export class AgentManager {
             if (this.manualReviewInFlight.has(taskId)) {
                 throw new ApiError(409, `Manual review already in progress for task ${taskId}`);
             }
+            // A mark-complete merge is mid-flight — refuse so Call review can't flip the
+            // merge-ready task back to review while the PR is being merged.
+            if (this.markCompleteInFlight.has(taskId)) {
+                throw new ApiError(409, `Task ${taskId} is being completed (merge in progress); try again shortly`);
+            }
             const task = await this.taskStore.get(taskId);
             if (!task)
                 throw new ApiError(404, `Task ${taskId} not found`);
+            // spec-phase max_rounds escapes via Retry/Cancel only. Call review dispatches the
+            // CODE-review protocol, but review.submitted early-returns for spec phase — so a direct
+            // /tasks/:id/review here would transition the task to review + bind QA, yet its verdict
+            // could never advance it or release the QA. Guard the server entry (UI already hides it),
+            // matching the continue/complete spec guards.
+            if (task.phase === 'spec' && task.status === 'max_rounds') {
+                throw new ApiError(409, `Call review is not supported for spec-phase max_rounds tasks (use Retry or Cancel)`);
+            }
             if (!task.prNumber) {
                 throw new ApiError(400, `Task ${taskId} has no PR yet; cannot dispatch review`);
             }
@@ -3338,19 +3393,26 @@ export class AgentManager {
             // emit dev-parked intervention 的旗标。
             // .catch→false: 旧 approved 分支已有此模式，markAgentWaiting reject (store/lock IO 异常) 时
             // 不能直接跳出 try/finally — QA 已 acquire (binding+lock) 必须先 release 清理才能 throw。
+            // Park dev only when it is still bound to THIS task. A paused max_rounds task
+            // released its dev (spec phase) or kept it reserved (code phase); a released
+            // dev has no running session to park, and markAgentWaiting would fail the
+            // taskId-match check (manager.ts releaseAgentForTask) → spurious 500.
             let devParked = false;
             if (!isTerminal && devAgentId) {
-                const devOk = await this.markAgentWaiting(devAgentId, taskId)
-                    .catch(err => {
-                    console.warn(`[dispatchReviewToQa] markAgentWaiting(dev=${devAgentId}) threw:`, err);
-                    return false;
-                });
-                if (!devOk) {
-                    await this.releaseAgentForTask(qaId, taskId, 'idle')
-                        .catch(() => undefined);
-                    throw new ApiError(500, `Cannot park dev ${devAgentId} into waiting for manual QA review (task status=${taskStatusAtClaim}); QA released`);
+                const devState = await this.agentStore.get(devAgentId);
+                if (devState?.taskId === taskId) {
+                    const devOk = await this.markAgentWaiting(devAgentId, taskId)
+                        .catch(err => {
+                        console.warn(`[dispatchReviewToQa] markAgentWaiting(dev=${devAgentId}) threw:`, err);
+                        return false;
+                    });
+                    if (!devOk) {
+                        await this.releaseAgentForTask(qaId, taskId, 'idle')
+                            .catch(() => undefined);
+                        throw new ApiError(500, `Cannot park dev ${devAgentId} into waiting for manual QA review (task status=${taskStatusAtClaim}); QA released`);
+                    }
+                    devParked = true;
                 }
-                devParked = true;
             }
             // PHASE 0 — snapshot fields PHASE 1/2 may overwrite, so rollback can
             // restore them exactly (qaAgentId / signalToken / reviewHeadAnchorSha).
@@ -3471,6 +3533,89 @@ export class AgentManager {
             this.manualReviewInFlight.delete(taskId);
         }
     }
+    // Manually push a code-phase max_rounds task through one more dev fix round.
+    // Reuses the fixing dispatch chain (fixing → pr-fixed watcher → continueSession),
+    // bypassing the review cap for this one round; the round still increments and the
+    // task re-pauses at max_rounds if QA requests changes again. The dev is the
+    // reserved one from the pause (§2.1), so its worktree is reused as-is.
+    async continueDevRound(taskId) {
+        // A mark-complete merge may be mid-flight after claiming the task but before the
+        // max_rounds → merge-ready transition lands; refuse so the two can't both act on the
+        // same max_rounds snapshot (the merge-ready status guard covers the post-transition window).
+        if (this.markCompleteInFlight.has(taskId)) {
+            throw new ApiError(409, `Task ${taskId} is being completed (merge in progress); try again shortly`);
+        }
+        const task = await this.taskStore.get(taskId);
+        if (!task)
+            throw new ApiError(404, `Task ${taskId} not found`);
+        if (task.status !== 'max_rounds') {
+            throw new ApiError(409, `Task ${taskId} is not at max_rounds (status=${task.status})`);
+        }
+        if (task.phase === 'spec') {
+            throw new ApiError(409, `Continue one round is only supported for code-phase tasks`);
+        }
+        if (!task.prNumber || !task.branch) {
+            throw new ApiError(400, `Task ${taskId} has no PR/branch; cannot continue`);
+        }
+        if (!task.agentId) {
+            throw new ApiError(400, `Task ${taskId} has no dev agent; cannot continue`);
+        }
+        // Retained-dev precondition: the paused dev must still hold this task and its
+        // worktree. If broken (cancelled, reassigned, external interference), continueSession
+        // would have no checkout to reuse — steer the user to Retry instead of recreating it.
+        const devAgentId = task.agentId;
+        const devState = await this.agentStore.get(devAgentId);
+        if (devState?.taskId !== taskId || !devState.worktreePath) {
+            // code-phase max_rounds has no Retry (Continue/Complete/Cancel only), so don't
+            // point at Retry: the work is on the PR — merge it (mark-complete) or abandon (cancel).
+            throw new ApiError(409, `Dev ${devAgentId} no longer holds task ${taskId}'s reserved worktree (cannot continue); ` +
+                `use mark-complete to merge the PR as-is, or cancel the task`);
+        }
+        const prevReviewRound = task.reviewRound;
+        const transitioned = await this.transitionTaskStatus(taskId, 'fixing', { fromStatus: ['max_rounds'] }, { reviewRound: prevReviewRound + 1, fixDispatchedAt: new Date().toISOString() });
+        if (!transitioned) {
+            throw new ApiError(409, `Task ${taskId} changed status during continue; aborted`);
+        }
+        const rollback = async () => {
+            await this.transitionTaskStatus(taskId, 'max_rounds', { fromStatus: ['fixing'] }, { reviewRound: prevReviewRound }).catch(() => undefined);
+        };
+        const acquired = await this.acquireAgentForTask(devAgentId, taskId, 'fix');
+        if (!acquired) {
+            await rollback();
+            throw new ApiError(409, `Dev ${devAgentId} is no longer available for task ${taskId}`);
+        }
+        const { armed } = await this.rotateAndSetupPhaseSignal(taskId, devAgentId, 'pr-fixed');
+        if (!armed) {
+            await this.markAwaitingHuman(devAgentId, 'signal-arm-failed:pr-fixed', 'pr-fixed watcher failed to arm; the fix was not dispatched (its completion signal would have no consumer). Cancel the task or delete the agent to retry.', { expectedTaskId: taskId });
+            await rollback();
+            throw new ApiError(500, `Failed to arm pr-fixed watcher for task ${taskId}`);
+        }
+        // rollback returns the task to max_rounds AND re-parks the dev to waiting, keeping
+        // the reserved-dev invariant (bound + 'waiting' + worktree) so a later continue/cancel
+        // sees a consistent state and the snapshot shows 'waiting', not a stale 'working'.
+        const rollbackAndRepark = async () => {
+            await rollback();
+            await this.markAgentWaiting(devAgentId, taskId).catch(() => undefined);
+        };
+        let resumed = false;
+        try {
+            resumed = await this.continueSession(taskId, devAgentId, 'fix');
+        }
+        catch (err) {
+            if (err instanceof DispatchTerminalError) {
+                await this.failTaskForDispatchError(taskId, 'fix', devAgentId, err);
+                throw new ApiError(500, `Continue dispatch failed: ${err.message}`);
+            }
+            await rollbackAndRepark();
+            throw err;
+        }
+        if (!resumed) {
+            await rollbackAndRepark();
+            throw new ApiError(500, `Failed to dispatch fix to dev ${devAgentId} for task ${taskId}`);
+        }
+        const fresh = await this.taskStore.get(taskId);
+        return fresh;
+    }
     // Undo PHASE 1+2 of dispatchReviewToQa when startSession ultimately fails
     // (resolved false, or threw a hard error other than ack_unknown / dialog).
     // Restores task fields to the pre-dispatch snapshot and re-establishes the pane-signal
@@ -3603,7 +3748,11 @@ export class AgentManager {
             const t = await this.taskStore.get(taskId);
             if (!t)
                 throw new ApiError(404, 'Task not found');
-            if (!TERMINAL_STATUSES.includes(t.status)) {
+            // max_rounds is non-terminal but still retryable for spec-phase tasks (their
+            // only escape this iteration). code-phase max_rounds uses continue/complete/cancel.
+            const retryable = TERMINAL_STATUSES.includes(t.status)
+                || (t.status === 'max_rounds' && t.phase === 'spec');
+            if (!retryable) {
                 throw new ApiError(409, `Task ${taskId} cannot be retried in status "${t.status}"; cancel it first or wait for completion`);
             }
             return t;
@@ -3619,6 +3768,12 @@ export class AgentManager {
             input.images = await this.readStagedImages(old.id, old.images);
         }
         await this.validateTaskDispatch(old.projectId, input);
+        // Non-terminal retry (spec-phase max_rounds) must finalize the old paused task so it
+        // leaves the active list instead of lingering beside the fresh run. Terminal tasks
+        // already are their own history record and are left untouched.
+        if (!TERMINAL_STATUSES.includes(old.status)) {
+            await this.cancelTask(old.id);
+        }
         return this.createAndStartTask(old.projectId, input);
     }
     async editTask(taskId, patch) {
@@ -3679,6 +3834,80 @@ export class AgentManager {
             throw new Error(`gh pr merge failed for PR #${task.prNumber}: ${result.stderr || result.stdout}`);
         }
     }
+    // Manually finish a max_rounds task: merge its PR, then reuse the normal merged
+    // cleanup chain (pr.merged handler → transition merged + post-merge worktree/branch
+    // cleanup + /compact + release). Same path the poller drives when it detects the merge.
+    async markTaskComplete(taskId) {
+        const task = await this.taskStore.get(taskId);
+        if (!task)
+            throw new ApiError(404, `Task ${taskId} not found`);
+        if (task.status !== 'max_rounds') {
+            throw new ApiError(409, `Task ${taskId} is not at max_rounds (status=${task.status})`);
+        }
+        // spec-phase max_rounds escapes via Retry/Cancel only (the UI hides complete). Guard the
+        // endpoint too so a direct API call / older client can't merge a spec cap through here.
+        if (task.phase === 'spec') {
+            throw new ApiError(409, `Mark complete is only supported for code-phase tasks`);
+        }
+        if (!task.prNumber || !task.branch) {
+            throw new ApiError(400, `Task ${taskId} has no PR/branch; cannot mark complete`);
+        }
+        // Claim the task for the whole merge window. markCompleteInFlight blocks Cancel /
+        // Call review / Continue (all re-check it under the task lock) so they can't act on
+        // the same max_rounds snapshot and interleave with the irreversible `gh pr merge`.
+        if (this.markCompleteInFlight.has(taskId)) {
+            throw new ApiError(409, `Task ${taskId} is already being completed`);
+        }
+        this.markCompleteInFlight.add(taskId);
+        try {
+            // Held-agent check AFTER claiming (the claim blocks a new continueDevRound from starting),
+            // and re-reading agent state here catches a continue that Held an agent in the window just
+            // before our claim. dispatchPostMergeCleanup early-returns on awaiting_human, so merging with
+            // a held dev/QA still bound to this task would orphan the merged task on a locked agent.
+            // Bound to *this* task only — a stale id whose agent moved on is harmless (cleanup early-returns).
+            for (const agentId of [task.agentId, task.qaAgentId]) {
+                if (!agentId)
+                    continue;
+                const state = await this.agentStore.get(agentId);
+                if (state?.status === 'awaiting_human' && state.taskId === taskId) {
+                    throw new ApiError(409, `Agent ${agentId} is awaiting human intervention on this task; resume/restart/delete it before marking complete`);
+                }
+            }
+            // Atomically transition max_rounds → merge-ready under the task lock. merge-ready is
+            // active + already in pr.merged's fromStatus, so the post-merge cleanup chain runs;
+            // combined with the in-flight claim it fully serializes against the other actions.
+            const claimed = await this.transitionTaskStatus(taskId, 'merge-ready', { fromStatus: ['max_rounds'] });
+            if (!claimed) {
+                throw new ApiError(409, `Task ${taskId} changed status during mark-complete; aborted`);
+            }
+            try {
+                await this.mergePr(taskId);
+            }
+            catch (err) {
+                await this.transitionTaskStatus(taskId, 'max_rounds', { fromStatus: ['merge-ready'] })
+                    .catch(() => undefined);
+                const message = err instanceof Error ? err.message : String(err);
+                throw new ApiError(409, `Merge failed for task ${taskId}: ${message}`);
+            }
+            await this.eventBus.emit({
+                id: '',
+                type: 'pr.merged',
+                timestamp: new Date().toISOString(),
+                projectId: task.projectId,
+                agentId: task.agentId,
+                taskId: task.id,
+                data: {
+                    prNumber: task.prNumber,
+                    ...(task.prUrl ? { prUrl: task.prUrl } : {}),
+                },
+            });
+            const fresh = await this.taskStore.get(taskId);
+            return fresh;
+        }
+        finally {
+            this.markCompleteInFlight.delete(taskId);
+        }
+    }
     async cleanupAfterMerge(taskId) {
         const task = await this.taskStore.get(taskId);
         if (!task || !task.agentId)
@@ -3884,7 +4113,7 @@ export class AgentManager {
                 throw new Error(`waitForReplPromptReady: pane ${paneId} pane_current_command=${current.trim()} (not runtime, REPL may have exited)`);
             }
             const cap = await tmux.capturePaneById(paneId, { ansi: false, scrollback: 0 });
-            const ready = hasReplReadyAnchor(cap, runtime);
+            const ready = hasRuntimeReadyView(cap, runtime);
             if (detectRuntimeMenu(cap) || (!ready && detectStartupDialog(cap, runtime))) {
                 throw new Error(`waitForReplPromptReady: pane ${paneId} shows menu/dialog, not a ready REPL prompt`);
             }