@jingyi0605/codingns 0.3.6 → 0.4.0

package/dist/server/modules/butler/butler-follow-up-service.js

@@ -23,6 +23,12 @@ const FOLLOW_UP_AUTO_APPROVE_ACTION_PREFERENCE = [
     "once",
     "allow"
 ];
+class FollowUpTaskCancelledError extends Error {
+    constructor() {
+        super("FOLLOW_UP_TASK_CANCELLED");
+        this.name = "FollowUpTaskCancelledError";
+    }
+}
 export class ButlerFollowUpService {
     butlerProfileService;
     butlerProjectService;
@@ -38,6 +44,7 @@ export class ButlerFollowUpService {
     sourceCodexHomeDir;
     sessionMessageOriginRepository;
     permissionRequestSweepAtByTaskId = new Map();
+    activeExecutionStateByTaskId = new Map();
     constructor(butlerProfileService, butlerProjectService, butlerSessionService, butlerFollowUpTaskRepository, sessionHistoryService, sessionIndexRepository, sessionLiveRuntimeService, workspaceService, providerAdapterRegistry, instructionAdapter, followUpCodexHomeDir = null, sourceCodexHomeDir = null, sessionMessageOriginRepository = null) {
         this.butlerProfileService = butlerProfileService;
         this.butlerProjectService = butlerProjectService;
@@ -129,7 +136,7 @@ export class ButlerFollowUpService {
         const processed = await this.processTask(task.id);
         return mapTaskView(processed, project.workspaceId, project.name, session.title ?? null);
     }
-    cancelTask(taskId, userId) {
+    async cancelTask(taskId, userId) {
         this.butlerProfileService.ensureInitialized();
         const task = this.butlerFollowUpTaskRepository.findById(taskId);
         if (!task) {
@@ -153,6 +160,7 @@ export class ButlerFollowUpService {
                 detail: "当前跟进任务已经结束，不能再次停止"
             });
         }
+        const execution = this.markTaskExecutionCancelled(task.id);
         const timestamp = nowIso();
         const updated = this.persistWithRound({
             ...task,
@@ -173,6 +181,7 @@ export class ButlerFollowUpService {
             autoContinueCount: task.autoContinueCount,
             createdAt: timestamp
         });
+        await this.stopActiveTaskAutomation(execution);
         const project = this.butlerProjectService.getById(updated.projectId);
         const index = this.sessionIndexRepository.findIndexRecordBySessionId(updated.sessionId);
         return mapTaskView(updated, project.workspaceId, project.name, index?.title ?? null);
@@ -225,117 +234,101 @@ export class ButlerFollowUpService {
         if (task.status !== "active") {
             return task;
         }
-        const profile = this.butlerProfileService.ensureInitialized();
-        const project = this.butlerProjectService.getById(task.projectId);
-        const inspection = await this.inspectTask(task);
-        const runningState = normalizeRunningState(inspection.runningState);
-        const baseUpdate = {
-            ...task,
-            lastCheckedAt: referenceAt,
-            lastObservedRunningState: runningState,
-            lastObservedMessageAt: inspection.messageAt,
-            lastObservedMessageCount: inspection.messageCount,
-            updatedAt: referenceAt
-        };
-        if (runningState === "starting" || runningState === "running") {
-            return this.persist({
-                ...baseUpdate,
-                status: "active",
-                waitingReason: null,
-                nextCheckAt: shiftSeconds(referenceAt, task.checkIntervalSeconds),
-                lastAutomationSummary: hasReachedAutoContinueLimit(task)
-                    ? `会话仍在运行，但已达到预设的自动跟进轮数上限（${task.autoContinueCount}/${task.maxAutoContinueCount}），本轮结束后将停止自动续接。`
-                    : "会话仍在运行，助手继续观察当前进度。"
-            });
-        }
-        if (hasReachedAutoContinueLimit(task)) {
-            const waitingReason = `已达到预设的自动跟进轮数上限（${task.autoContinueCount}/${task.maxAutoContinueCount}），如需继续，请手动重新发起跟进。`;
-            const summary = `自动跟进已按预设上限停止。结束条件：${task.completionCriteria}`;
-            return this.persistWithRound({
-                ...baseUpdate,
-                status: "waiting_user",
-                waitingReason,
-                nextCheckAt: null,
-                completedAt: null,
-                lastAutomationAt: referenceAt,
-                lastAutomationSummary: summary
-            }, {
-                kind: "limit_reached",
-                status: "waiting_user",
-                summary,
-                waitingReason,
-                continuePrompt: null,
-                observedRunningState: runningState,
-                autoContinueCount: task.autoContinueCount,
-                createdAt: referenceAt
-            });
-        }
+        const execution = this.beginTaskExecution(task.id);
         try {
-            const evaluation = await this.evaluateTask(profile, project, task, inspection, runningState);
-            switch (evaluation.decision) {
-                case "completed":
-                    return this.persistWithRound({
-                        ...baseUpdate,
-                        status: "completed",
-                        waitingReason: null,
-                        nextCheckAt: null,
-                        completedAt: referenceAt,
-                        lastAutomationAt: referenceAt,
-                        lastAutomationSummary: evaluation.summary
-                    }, {
-                        kind: "completed",
-                        status: "completed",
-                        summary: evaluation.summary,
-                        waitingReason: null,
-                        continuePrompt: null,
-                        observedRunningState: runningState,
-                        autoContinueCount: task.autoContinueCount,
-                        createdAt: referenceAt
-                    });
-                case "waiting_user":
-                    return this.persistWithRound({
-                        ...baseUpdate,
-                        status: "waiting_user",
-                        waitingReason: evaluation.waitingReason ?? evaluation.summary,
-                        nextCheckAt: null,
-                        completedAt: null,
-                        lastAutomationAt: referenceAt,
-                        lastAutomationSummary: evaluation.summary
-                    }, {
-                        kind: "waiting_user",
-                        status: "waiting_user",
-                        summary: evaluation.summary,
-                        waitingReason: evaluation.waitingReason ?? evaluation.summary,
-                        continuePrompt: null,
-                        observedRunningState: runningState,
-                        autoContinueCount: task.autoContinueCount,
-                        createdAt: referenceAt
-                    });
-                case "failed":
-                    return this.persistWithRound({
-                        ...baseUpdate,
-                        status: "failed",
-                        waitingReason: evaluation.waitingReason ?? evaluation.summary,
-                        nextCheckAt: null,
-                        completedAt: null,
-                        lastAutomationAt: referenceAt,
-                        lastAutomationSummary: evaluation.summary
-                    }, {
-                        kind: "failed",
-                        status: "failed",
-                        summary: evaluation.summary,
-                        waitingReason: evaluation.waitingReason ?? evaluation.summary,
-                        continuePrompt: null,
-                        observedRunningState: runningState,
-                        autoContinueCount: task.autoContinueCount,
-                        createdAt: referenceAt
-                    });
-                case "continue":
-                    if (!evaluation.continuePrompt) {
-                        return this.persistWithRound({
+            const profile = this.butlerProfileService.ensureInitialized();
+            const project = this.butlerProjectService.getById(task.projectId);
+            const inspection = await this.inspectTask(task);
+            this.ensureTaskExecutionActive(task.id, execution);
+            const runningState = normalizeRunningState(inspection.runningState);
+            const baseUpdate = {
+                ...task,
+                lastCheckedAt: referenceAt,
+                lastObservedRunningState: runningState,
+                lastObservedMessageAt: inspection.messageAt,
+                lastObservedMessageCount: inspection.messageCount,
+                updatedAt: referenceAt
+            };
+            if (runningState === "starting" || runningState === "running") {
+                return this.persistIfExecutionActive(task.id, execution, {
+                    ...baseUpdate,
+                    status: "active",
+                    waitingReason: null,
+                    nextCheckAt: shiftSeconds(referenceAt, task.checkIntervalSeconds),
+                    lastAutomationSummary: hasReachedAutoContinueLimit(task)
+                        ? `会话仍在运行，但已达到预设的自动跟进轮数上限（${task.autoContinueCount}/${task.maxAutoContinueCount}），本轮结束后将停止自动续接。`
+                        : "会话仍在运行，助手继续观察当前进度。"
+                });
+            }
+            if (hasReachedAutoContinueLimit(task)) {
+                const waitingReason = `已达到预设的自动跟进轮数上限（${task.autoContinueCount}/${task.maxAutoContinueCount}），如需继续，请手动重新发起跟进。`;
+                const summary = `自动跟进已按预设上限停止。结束条件：${task.completionCriteria}`;
+                return this.persistWithRoundIfExecutionActive(task.id, execution, {
+                    ...baseUpdate,
+                    status: "waiting_user",
+                    waitingReason,
+                    nextCheckAt: null,
+                    completedAt: null,
+                    lastAutomationAt: referenceAt,
+                    lastAutomationSummary: summary
+                }, {
+                    kind: "limit_reached",
+                    status: "waiting_user",
+                    summary,
+                    waitingReason,
+                    continuePrompt: null,
+                    observedRunningState: runningState,
+                    autoContinueCount: task.autoContinueCount,
+                    createdAt: referenceAt
+                });
+            }
+            try {
+                const evaluation = await this.evaluateTask(profile, project, task, inspection, runningState, execution);
+                this.ensureTaskExecutionActive(task.id, execution);
+                switch (evaluation.decision) {
+                    case "completed":
+                        return this.persistWithRoundIfExecutionActive(task.id, execution, {
+                            ...baseUpdate,
+                            status: "completed",
+                            waitingReason: null,
+                            nextCheckAt: null,
+                            completedAt: referenceAt,
+                            lastAutomationAt: referenceAt,
+                            lastAutomationSummary: evaluation.summary
+                        }, {
+                            kind: "completed",
+                            status: "completed",
+                            summary: evaluation.summary,
+                            waitingReason: null,
+                            continuePrompt: null,
+                            observedRunningState: runningState,
+                            autoContinueCount: task.autoContinueCount,
+                            createdAt: referenceAt
+                        });
+                    case "waiting_user":
+                        return this.persistWithRoundIfExecutionActive(task.id, execution, {
+                            ...baseUpdate,
+                            status: "waiting_user",
+                            waitingReason: evaluation.waitingReason ?? evaluation.summary,
+                            nextCheckAt: null,
+                            completedAt: null,
+                            lastAutomationAt: referenceAt,
+                            lastAutomationSummary: evaluation.summary
+                        }, {
+                            kind: "waiting_user",
+                            status: "waiting_user",
+                            summary: evaluation.summary,
+                            waitingReason: evaluation.waitingReason ?? evaluation.summary,
+                            continuePrompt: null,
+                            observedRunningState: runningState,
+                            autoContinueCount: task.autoContinueCount,
+                            createdAt: referenceAt
+                        });
+                    case "failed":
+                        return this.persistWithRoundIfExecutionActive(task.id, execution, {
                             ...baseUpdate,
                             status: "failed",
-                            waitingReason: "后台评估助手没有返回可继续推进的指令。",
+                            waitingReason: evaluation.waitingReason ?? evaluation.summary,
                             nextCheckAt: null,
                             completedAt: null,
                             lastAutomationAt: referenceAt,
@@ -344,90 +337,121 @@ export class ButlerFollowUpService {
                             kind: "failed",
                             status: "failed",
                             summary: evaluation.summary,
-                            waitingReason: "后台评估助手没有返回可继续推进的指令。",
+                            waitingReason: evaluation.waitingReason ?? evaluation.summary,
+                            continuePrompt: null,
+                            observedRunningState: runningState,
+                            autoContinueCount: task.autoContinueCount,
+                            createdAt: referenceAt
+                        });
+                    case "continue":
+                        if (!evaluation.continuePrompt) {
+                            return this.persistWithRoundIfExecutionActive(task.id, execution, {
+                                ...baseUpdate,
+                                status: "failed",
+                                waitingReason: "后台评估助手没有返回可继续推进的指令。",
+                                nextCheckAt: null,
+                                completedAt: null,
+                                lastAutomationAt: referenceAt,
+                                lastAutomationSummary: evaluation.summary
+                            }, {
+                                kind: "failed",
+                                status: "failed",
+                                summary: evaluation.summary,
+                                waitingReason: "后台评估助手没有返回可继续推进的指令。",
+                                continuePrompt: null,
+                                observedRunningState: runningState,
+                                autoContinueCount: task.autoContinueCount,
+                                createdAt: referenceAt
+                            });
+                        }
+                        this.ensureTaskExecutionActive(task.id, execution);
+                        const sendResult = await this.sendContinuePrompt(task, evaluation.continuePrompt, referenceAt);
+                        this.ensureTaskExecutionActive(task.id, execution);
+                        this.butlerSessionService.captureSessionSnapshot(task.projectId, task.butlerSessionId, task.createdByUserId, { sourceKind: "manual" });
+                        const nextAutoContinueCount = task.autoContinueCount + 1;
+                        const nextSummary = sendResult.delivery === "queued"
+                            ? buildQueuedFollowUpSummary(evaluation.summary, sendResult.queueItem)
+                            : evaluation.summary;
+                        return this.persistWithRoundIfExecutionActive(task.id, execution, {
+                            ...baseUpdate,
+                            status: "active",
+                            waitingReason: null,
+                            nextCheckAt: shiftSeconds(referenceAt, task.checkIntervalSeconds),
+                            lastAutomationAt: referenceAt,
+                            autoContinueCount: nextAutoContinueCount,
+                            lastAutomationSummary: nextSummary
+                        }, {
+                            kind: sendResult.delivery === "queued" ? "queued" : "continue",
+                            status: "active",
+                            summary: nextSummary,
+                            waitingReason: null,
+                            continuePrompt: evaluation.continuePrompt,
+                            observedRunningState: runningState,
+                            autoContinueCount: nextAutoContinueCount,
+                            createdAt: referenceAt
+                        });
+                    default:
+                        return this.persistWithRoundIfExecutionActive(task.id, execution, {
+                            ...baseUpdate,
+                            status: "failed",
+                            waitingReason: "后台评估助手返回了不支持的决策。",
+                            nextCheckAt: null,
+                            completedAt: null,
+                            lastAutomationAt: referenceAt,
+                            lastAutomationSummary: "后台评估助手返回了不支持的决策。"
+                        }, {
+                            kind: "failed",
+                            status: "failed",
+                            summary: "后台评估助手返回了不支持的决策。",
+                            waitingReason: "后台评估助手返回了不支持的决策。",
                             continuePrompt: null,
                             observedRunningState: runningState,
                             autoContinueCount: task.autoContinueCount,
                             createdAt: referenceAt
                         });
-                    }
-                    const sendResult = await this.sendContinuePrompt(task, evaluation.continuePrompt, referenceAt);
-                    this.butlerSessionService.captureSessionSnapshot(task.projectId, task.butlerSessionId, task.createdByUserId, { sourceKind: "manual" });
-                    const nextAutoContinueCount = task.autoContinueCount + 1;
-                    const nextSummary = sendResult.delivery === "queued"
-                        ? buildQueuedFollowUpSummary(evaluation.summary, sendResult.queueItem)
-                        : evaluation.summary;
-                    return this.persistWithRound({
+                }
+            }
+            catch (error) {
+                if (error instanceof FollowUpTaskCancelledError) {
+                    return this.butlerFollowUpTaskRepository.findById(task.id) ?? task;
+                }
+                if (isDeferredFollowUpSendError(error)) {
+                    return this.persistIfExecutionActive(task.id, execution, {
                         ...baseUpdate,
                         status: "active",
                         waitingReason: null,
                         nextCheckAt: shiftSeconds(referenceAt, task.checkIntervalSeconds),
-                        lastAutomationAt: referenceAt,
-                        autoContinueCount: nextAutoContinueCount,
-                        lastAutomationSummary: nextSummary
-                    }, {
-                        kind: sendResult.delivery === "queued" ? "queued" : "continue",
-                        status: "active",
-                        summary: nextSummary,
-                        waitingReason: null,
-                        continuePrompt: evaluation.continuePrompt,
-                        observedRunningState: runningState,
-                        autoContinueCount: nextAutoContinueCount,
-                        createdAt: referenceAt
-                    });
-                default:
-                    return this.persistWithRound({
-                        ...baseUpdate,
-                        status: "failed",
-                        waitingReason: "后台评估助手返回了不支持的决策。",
-                        nextCheckAt: null,
                         completedAt: null,
                         lastAutomationAt: referenceAt,
-                        lastAutomationSummary: "后台评估助手返回了不支持的决策。"
-                    }, {
-                        kind: "failed",
-                        status: "failed",
-                        summary: "后台评估助手返回了不支持的决策。",
-                        waitingReason: "后台评估助手返回了不支持的决策。",
-                        continuePrompt: null,
-                        observedRunningState: runningState,
-                        autoContinueCount: task.autoContinueCount,
-                        createdAt: referenceAt
+                        lastAutomationSummary: "当前会话又进入运行态，本轮不插话，等待下一次检查。"
                     });
-            }
-        }
-        catch (error) {
-            if (isDeferredFollowUpSendError(error)) {
-                return this.persist({
+                }
+                const detail = error instanceof Error ? error.message : String(error);
+                const summary = `后台评估助手执行失败：${detail}`;
+                return this.persistWithRoundIfExecutionActive(task.id, execution, {
                     ...baseUpdate,
-                    status: "active",
-                    waitingReason: null,
-                    nextCheckAt: shiftSeconds(referenceAt, task.checkIntervalSeconds),
+                    status: "failed",
+                    waitingReason: detail,
+                    nextCheckAt: null,
                     completedAt: null,
                     lastAutomationAt: referenceAt,
-                    lastAutomationSummary: "当前会话又进入运行态，本轮不插话，等待下一次检查。"
+                    lastAutomationSummary: summary
+                }, {
+                    kind: "failed",
+                    status: "failed",
+                    summary,
+                    waitingReason: detail,
+                    continuePrompt: null,
+                    observedRunningState: runningState,
+                    autoContinueCount: task.autoContinueCount,
+                    createdAt: referenceAt
                 });
             }
-            const detail = error instanceof Error ? error.message : String(error);
-            const summary = `后台评估助手执行失败：${detail}`;
-            return this.persistWithRound({
-                ...baseUpdate,
-                status: "failed",
-                waitingReason: detail,
-                nextCheckAt: null,
-                completedAt: null,
-                lastAutomationAt: referenceAt,
-                lastAutomationSummary: summary
-            }, {
-                kind: "failed",
-                status: "failed",
-                summary,
-                waitingReason: detail,
-                continuePrompt: null,
-                observedRunningState: runningState,
-                autoContinueCount: task.autoContinueCount,
-                createdAt: referenceAt
-            });
+        }
+        finally {
+            if (this.activeExecutionStateByTaskId.get(task.id) === execution) {
+                this.activeExecutionStateByTaskId.delete(task.id);
+            }
         }
     }
     persist(task) {
@@ -447,6 +471,18 @@ export class ButlerFollowUpService {
             rounds: [...normalizedRounds, createFollowUpRound(normalizedRounds, round)]
         });
     }
+    persistIfExecutionActive(taskId, execution, task) {
+        if (!this.isTaskExecutionActive(taskId, execution)) {
+            return this.butlerFollowUpTaskRepository.findById(taskId) ?? task;
+        }
+        return this.persist(task);
+    }
+    persistWithRoundIfExecutionActive(taskId, execution, task, round) {
+        if (!this.isTaskExecutionActive(taskId, execution)) {
+            return this.butlerFollowUpTaskRepository.findById(taskId) ?? task;
+        }
+        return this.persistWithRound(task, round);
+    }
     async autoApprovePendingPermissionRequestsIfDue(task, referenceAt) {
         const parsedReferenceAt = Date.parse(referenceAt);
         const referenceAtMs = Number.isFinite(parsedReferenceAt) ? parsedReferenceAt : Date.now();
@@ -568,7 +604,7 @@ export class ButlerFollowUpService {
             transcriptLines: sortedMessages.map((message) => renderHistoryLine(message.sequence, message.role, message.kind ?? "text", message.timestamp, message.content))
         };
     }
-    async evaluateTask(profile, project, task, inspection, runningState) {
+    async evaluateTask(profile, project, task, inspection, runningState, execution) {
         const evaluatorWorkspacePath = path.join(profile.workspacePath, FOLLOW_UP_EVALUATOR_DIRNAME);
         ensureButlerWorkspaceIsolation(evaluatorWorkspacePath);
         this.writeEvaluationInstructionFiles(evaluatorWorkspacePath, profile.providerId);
@@ -599,11 +635,64 @@ export class ButlerFollowUpService {
             prompt: instruction.prompt,
             model: resolveFollowUpModel(profile.providerId, this.sourceCodexHomeDir),
             reasoningLevel: "low",
-            permissionMode: "default"
+            permissionMode: "default",
+            instructionFilePath: resolveFollowUpInstructionFilePath(profile.providerId, evaluatorWorkspacePath)
         });
-        await adapter.waitForSessionTerminal(launch.sessionId);
-        const result = await adapter.readPatrolResult(launch.sessionId);
-        return parseEvaluationResult(result);
+        execution.evaluatorSessionId = launch.sessionId;
+        try {
+            await adapter.waitForSessionTerminal(launch.sessionId);
+            this.ensureTaskExecutionActive(task.id, execution);
+            const result = await adapter.readPatrolResult(launch.sessionId);
+            return parseEvaluationResult(result);
+        }
+        finally {
+            if (execution.evaluatorSessionId === launch.sessionId) {
+                execution.evaluatorSessionId = null;
+            }
+        }
+    }
+    beginTaskExecution(taskId) {
+        const execution = {
+            cancelled: false,
+            evaluatorSessionId: null
+        };
+        this.activeExecutionStateByTaskId.set(taskId, execution);
+        return execution;
+    }
+    markTaskExecutionCancelled(taskId) {
+        const execution = this.activeExecutionStateByTaskId.get(taskId) ?? null;
+        if (execution) {
+            execution.cancelled = true;
+        }
+        return execution;
+    }
+    ensureTaskExecutionActive(taskId, execution) {
+        if (!this.isTaskExecutionActive(taskId, execution)) {
+            throw new FollowUpTaskCancelledError();
+        }
+    }
+    isTaskExecutionActive(taskId, execution) {
+        const current = this.activeExecutionStateByTaskId.get(taskId);
+        return Boolean(current && current === execution && !execution.cancelled);
+    }
+    async stopActiveTaskAutomation(execution) {
+        if (!execution?.evaluatorSessionId) {
+            return;
+        }
+        const profile = this.butlerProfileService.ensureInitialized();
+        const adapter = this.providerAdapterRegistry.get(profile.providerId);
+        try {
+            await adapter.interruptPatrolSession(execution.evaluatorSessionId);
+        }
+        catch (error) {
+            console.warn("[butler-follow-up] interrupt evaluator session failed", {
+                sessionId: execution.evaluatorSessionId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        finally {
+            execution.evaluatorSessionId = null;
+        }
     }
     writeEvaluationInstructionFiles(workspacePath, providerId) {
         const content = [
@@ -829,6 +918,9 @@ function resolveFollowUpModel(providerId, sourceCodexHomeDir) {
     }
     return resolveButlerCodexBackgroundModel("gpt-5.1-codex-mini", sourceCodexHomeDir);
 }
+function resolveFollowUpInstructionFilePath(providerId, workspacePath) {
+    return path.join(workspacePath, providerId === "claude-code" ? "CLAUDE.md" : "AGENTS.md");
+}
 function parseEvaluationResult(result) {
     const rawJson = result.structured.rawJson ?? extractJsonFromText(result.latestAssistantMessage);
     if (!rawJson) {