@jingyi0605/codingns 0.3.6 → 0.5.0

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

@@ -1,11 +1,9 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import { AppError } from "../../shared/errors/app-error.js";
 import { createId } from "../../shared/utils/id.js";
 import { nowIso } from "../../shared/utils/time.js";
-import { ensureButlerWorkspaceIsolation } from "./butler-profile-service.js";
 import { resolveButlerCodexBackgroundModel } from "./butler-codex-model-policy.js";
+import { normalizeProviderUsageLimit } from "../sessions/session-provider-usage-limit.js";
+import { resolveProviderUsageLimitBlockedUntil, resolveProviderUsageLimitFromError, SessionProviderUsageLimitGuardService } from "../sessions/session-provider-usage-guard-service.js";
 const DEFAULT_CHECK_INTERVAL_SECONDS = 300;
 const MIN_CHECK_INTERVAL_SECONDS = 60;
 const MAX_CHECK_INTERVAL_SECONDS = 3600;
@@ -15,6 +13,8 @@ const MAX_MAX_AUTO_CONTINUE_COUNT = 20;
 const FOLLOW_UP_EVALUATOR_DIRNAME = ".butler-follow-up-evaluator";
 const RECENT_HISTORY_LIMIT = 40;
 const FOLLOW_UP_PERMISSION_CHECK_INTERVAL_MS = 10_000;
+const FOLLOW_UP_ASSISTANT_WAIT_TIMEOUT_MS = 20 * 60_000;
+const FOLLOW_UP_ASSISTANT_WAIT_POLL_INTERVAL_MS = 2_000;
 const FOLLOW_UP_AUTO_APPROVE_ACTION_PREFERENCE = [
     "acceptForSession",
     "allow_session",
@@ -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;
@@ -37,8 +43,10 @@ export class ButlerFollowUpService {
     followUpCodexHomeDir;
     sourceCodexHomeDir;
     sessionMessageOriginRepository;
+    providerUsageLimitGuardService;
     permissionRequestSweepAtByTaskId = new Map();
-    constructor(butlerProfileService, butlerProjectService, butlerSessionService, butlerFollowUpTaskRepository, sessionHistoryService, sessionIndexRepository, sessionLiveRuntimeService, workspaceService, providerAdapterRegistry, instructionAdapter, followUpCodexHomeDir = null, sourceCodexHomeDir = null, sessionMessageOriginRepository = null) {
+    activeExecutionStateByTaskId = new Map();
+    constructor(butlerProfileService, butlerProjectService, butlerSessionService, butlerFollowUpTaskRepository, sessionHistoryService, sessionIndexRepository, sessionLiveRuntimeService, workspaceService, providerAdapterRegistry, instructionAdapter, followUpCodexHomeDir = null, sourceCodexHomeDir = null, sessionMessageOriginRepository = null, providerUsageLimitGuardService = new SessionProviderUsageLimitGuardService(sessionHistoryService)) {
         this.butlerProfileService = butlerProfileService;
         this.butlerProjectService = butlerProjectService;
         this.butlerSessionService = butlerSessionService;
@@ -52,6 +60,7 @@ export class ButlerFollowUpService {
         this.followUpCodexHomeDir = followUpCodexHomeDir;
         this.sourceCodexHomeDir = sourceCodexHomeDir;
         this.sessionMessageOriginRepository = sessionMessageOriginRepository;
+        this.providerUsageLimitGuardService = providerUsageLimitGuardService;
     }
     listTasks(filters = {}) {
         this.butlerProfileService.ensureInitialized();
@@ -78,9 +87,41 @@ export class ButlerFollowUpService {
         const index = this.sessionIndexRepository.findIndexRecordBySessionId(task.sessionId);
         return mapTaskView(task, project.workspaceId, project.name, index?.title ?? null);
     }
+    toTaskView(task) {
+        const project = this.butlerProjectService.getById(task.projectId);
+        const index = this.sessionIndexRepository.findIndexRecordBySessionId(task.sessionId);
+        return mapTaskView(task, project.workspaceId, project.name, index?.title ?? null);
+    }
+    requireTaskForAssistantUpdate(taskId, userId) {
+        this.butlerProfileService.ensureInitialized();
+        const task = this.butlerFollowUpTaskRepository.findById(taskId);
+        if (!task) {
+            throw new AppError({
+                statusCode: 404,
+                errorCode: "BUTLER_FOLLOW_UP_TASK_NOT_FOUND",
+                detail: "未找到对应的跟进任务"
+            });
+        }
+        if (task.createdByUserId !== userId) {
+            throw new AppError({
+                statusCode: 403,
+                errorCode: "BUTLER_FOLLOW_UP_TASK_FORBIDDEN",
+                detail: "你没有权限更新这个跟进任务"
+            });
+        }
+        if (task.status !== "active") {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "BUTLER_FOLLOW_UP_TASK_NOT_ACTIVE",
+                detail: "当前跟进任务已经不处于可回写状态"
+            });
+        }
+        return task;
+    }
     async createTask(input, userId) {
         this.butlerProfileService.ensureInitialized();
         const project = this.butlerProjectService.getById(input.projectId);
+        const providerId = normalizeFollowUpProviderId(input.providerId);
         const objective = normalizeObjective(input.objective);
         const completionCriteria = normalizeCompletionCriteria(input.completionCriteria, objective);
         const maxAutoContinueCount = normalizeMaxAutoContinueCount(input.maxAutoContinueCount);
@@ -95,15 +136,38 @@ export class ButlerFollowUpService {
             });
         }
         const session = this.sessionHistoryService.getSession(snapshot.sessionId, userId);
+        const inspection = await this.inspectSession(snapshot.sessionId, userId);
+        const assistantSession = await this.butlerSessionService.startSession(project.id, {
+            providerId,
+            role: "adhoc",
+            ownershipMode: "managed",
+            content: buildFollowUpBootstrapPrompt({
+                project,
+                sourceButlerSessionId: input.butlerSessionId,
+                sourceSessionId: snapshot.sessionId,
+                sourceSessionTitle: inspection.sessionTitle,
+                objective,
+                completionCriteria,
+                maxAutoContinueCount,
+                latestAssistantText: inspection.latestAssistantText,
+                transcriptLines: inspection.transcriptLines
+            }),
+            model: resolveFollowUpModel(providerId, this.sourceCodexHomeDir),
+            reasoningLevel: "low",
+            permissionMode: "default"
+        }, userId);
         const timestamp = nowIso();
         const initialSummary = snapshot.runningState === "starting" || snapshot.runningState === "running"
-            ? `已开始跟进，先等待当前运行结束，再由后台评估助手决定下一步。默认最多自动推进 ${maxAutoContinueCount} 轮。`
-            : `已开始跟进，准备由后台评估助手检查当前进展。默认最多自动推进 ${maxAutoContinueCount} 轮。`;
+            ? `已创建跟进助手会话，先等待当前运行结束，再由该会话决定是否继续推进。默认最多自动推进 ${maxAutoContinueCount} 轮。`
+            : `已创建跟进助手会话，准备由该会话检查当前进展并决定是否继续推进。默认最多自动推进 ${maxAutoContinueCount} 轮。`;
         const task = this.butlerFollowUpTaskRepository.create({
             id: createId(),
             projectId: project.id,
             butlerSessionId: input.butlerSessionId,
             sessionId: snapshot.sessionId,
+            providerId,
+            assistantButlerSessionId: assistantSession.id,
+            assistantSessionId: assistantSession.sessionId,
             createdByUserId: userId,
             objective,
             completionCriteria,
@@ -129,7 +193,144 @@ export class ButlerFollowUpService {
         const processed = await this.processTask(task.id);
         return mapTaskView(processed, project.workspaceId, project.name, session.title ?? null);
     }
-    cancelTask(taskId, userId) {
+    async continueTask(taskId, input, userId) {
+        const summary = requireNonEmptyFollowUpText(input.summary, "summary", "继续推进必须提供 summary");
+        const continuePrompt = requireNonEmptyFollowUpText(input.continuePrompt, "continuePrompt", "继续推进必须提供 continuePrompt");
+        const task = this.requireTaskForAssistantUpdate(taskId, userId);
+        if (hasReachedAutoContinueLimit(task)) {
+            throw new AppError({
+                statusCode: 409,
+                errorCode: "BUTLER_FOLLOW_UP_TASK_LIMIT_REACHED",
+                detail: "当前跟进任务已经达到自动推进上限，不能继续自动推进"
+            });
+        }
+        this.butlerSessionService.captureSessionSnapshot(task.projectId, task.butlerSessionId, task.createdByUserId, { sourceKind: "manual" });
+        const inspection = await this.inspectTask(task);
+        const timestamp = nowIso();
+        const runningState = normalizeRunningState(inspection.runningState);
+        const nextAutoContinueCount = task.autoContinueCount + 1;
+        const updated = this.persistWithRound({
+            ...task,
+            status: "active",
+            lastCheckedAt: timestamp,
+            lastObservedRunningState: runningState,
+            lastObservedMessageAt: inspection.messageAt,
+            lastObservedMessageCount: inspection.messageCount,
+            waitingReason: null,
+            nextCheckAt: shiftSeconds(timestamp, task.checkIntervalSeconds),
+            lastAutomationSummary: summary,
+            lastAutomationAt: timestamp,
+            autoContinueCount: nextAutoContinueCount,
+            updatedAt: timestamp,
+            completedAt: null
+        }, {
+            kind: "continue",
+            status: "active",
+            summary,
+            waitingReason: null,
+            continuePrompt,
+            observedRunningState: runningState,
+            autoContinueCount: nextAutoContinueCount,
+            createdAt: timestamp
+        });
+        return this.toTaskView(updated);
+    }
+    async markTaskWaitingUser(taskId, input, userId) {
+        const summary = requireNonEmptyFollowUpText(input.summary, "summary", "等待用户必须提供 summary");
+        const waitingReason = requireNonEmptyFollowUpText(input.waitingReason, "waitingReason", "等待用户必须提供 waitingReason");
+        const task = this.requireTaskForAssistantUpdate(taskId, userId);
+        const inspection = await this.inspectTask(task);
+        const timestamp = nowIso();
+        const runningState = normalizeRunningState(inspection.runningState);
+        const updated = this.persistWithRound({
+            ...task,
+            status: "waiting_user",
+            lastCheckedAt: timestamp,
+            lastObservedRunningState: runningState,
+            lastObservedMessageAt: inspection.messageAt,
+            lastObservedMessageCount: inspection.messageCount,
+            waitingReason,
+            nextCheckAt: null,
+            lastAutomationSummary: summary,
+            lastAutomationAt: timestamp,
+            updatedAt: timestamp,
+            completedAt: null
+        }, {
+            kind: "waiting_user",
+            status: "waiting_user",
+            summary,
+            waitingReason,
+            continuePrompt: null,
+            observedRunningState: runningState,
+            autoContinueCount: task.autoContinueCount,
+            createdAt: timestamp
+        });
+        return this.toTaskView(updated);
+    }
+    async completeTask(taskId, input, userId) {
+        const summary = requireNonEmptyFollowUpText(input.summary, "summary", "完成任务必须提供 summary");
+        const task = this.requireTaskForAssistantUpdate(taskId, userId);
+        const inspection = await this.inspectTask(task);
+        const timestamp = nowIso();
+        const runningState = normalizeRunningState(inspection.runningState);
+        const updated = this.persistWithRound({
+            ...task,
+            status: "completed",
+            lastCheckedAt: timestamp,
+            lastObservedRunningState: runningState,
+            lastObservedMessageAt: inspection.messageAt,
+            lastObservedMessageCount: inspection.messageCount,
+            waitingReason: null,
+            nextCheckAt: null,
+            lastAutomationSummary: summary,
+            lastAutomationAt: timestamp,
+            updatedAt: timestamp,
+            completedAt: timestamp
+        }, {
+            kind: "completed",
+            status: "completed",
+            summary,
+            waitingReason: null,
+            continuePrompt: null,
+            observedRunningState: runningState,
+            autoContinueCount: task.autoContinueCount,
+            createdAt: timestamp
+        });
+        return this.toTaskView(updated);
+    }
+    async failTask(taskId, input, userId) {
+        const summary = requireNonEmptyFollowUpText(input.summary, "summary", "标记失败必须提供 summary");
+        const reason = normalizeNullableText(input.reason) ?? summary;
+        const task = this.requireTaskForAssistantUpdate(taskId, userId);
+        const inspection = await this.inspectTask(task);
+        const timestamp = nowIso();
+        const runningState = normalizeRunningState(inspection.runningState);
+        const updated = this.persistWithRound({
+            ...task,
+            status: "failed",
+            lastCheckedAt: timestamp,
+            lastObservedRunningState: runningState,
+            lastObservedMessageAt: inspection.messageAt,
+            lastObservedMessageCount: inspection.messageCount,
+            waitingReason: reason,
+            nextCheckAt: null,
+            lastAutomationSummary: summary,
+            lastAutomationAt: timestamp,
+            updatedAt: timestamp,
+            completedAt: null
+        }, {
+            kind: "failed",
+            status: "failed",
+            summary,
+            waitingReason: reason,
+            continuePrompt: null,
+            observedRunningState: runningState,
+            autoContinueCount: task.autoContinueCount,
+            createdAt: timestamp
+        });
+        return this.toTaskView(updated);
+    }
+    async cancelTask(taskId, userId) {
         this.butlerProfileService.ensureInitialized();
         const task = this.butlerFollowUpTaskRepository.findById(taskId);
         if (!task) {
@@ -153,6 +354,7 @@ export class ButlerFollowUpService {
                 detail: "当前跟进任务已经结束，不能再次停止"
             });
         }
+        const execution = this.markTaskExecutionCancelled(task.id);
         const timestamp = nowIso();
         const updated = this.persistWithRound({
             ...task,
@@ -173,6 +375,7 @@ export class ButlerFollowUpService {
             autoContinueCount: task.autoContinueCount,
             createdAt: timestamp
         });
+        await this.stopActiveTaskAutomation(task, 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,209 +428,136 @@ 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({
+            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
+                });
+            }
+            const usageLimitBlock = await this.providerUsageLimitGuardService.resolveBlockingInspection([
+                {
+                    sessionId: task.sessionId,
+                    userId: task.createdByUserId,
+                    sourceLabel: "跟进目标会话"
+                },
+                {
+                    sessionId: task.assistantSessionId,
+                    userId: task.createdByUserId,
+                    sourceLabel: "跟进助手会话"
+                }
+            ], referenceAt);
+            if (usageLimitBlock) {
+                const nextCheckAt = usageLimitBlock.blockedUntil;
+                return this.persistIfExecutionActive(task.id, execution, {
+                    ...baseUpdate,
+                    status: "active",
+                    waitingReason: null,
+                    nextCheckAt,
+                    completedAt: null,
+                    lastAutomationAt: referenceAt,
+                    lastAutomationSummary: buildFollowUpUsageLimitSummary(usageLimitBlock.inspection.providerUsageLimit, `${usageLimitBlock.inspection.sourceLabel ?? "当前会话"}被 provider 套餐限额暂时挡住。`)
+                });
+            }
+            try {
+                const progressBeforeDispatch = snapshotTaskProgress(task);
+                await this.requestAssistantEvaluation(project, task, inspection, runningState, execution);
+                this.ensureTaskExecutionActive(task.id, execution);
+                return this.requireAssistantDecisionPersisted(task.id, progressBeforeDispatch);
+            }
+            catch (error) {
+                if (error instanceof FollowUpTaskCancelledError) {
+                    return this.butlerFollowUpTaskRepository.findById(task.id) ?? task;
+                }
+                const providerUsageLimit = resolveProviderUsageLimitFromError(error, task.providerId, referenceAt);
+                if (providerUsageLimit) {
+                    return this.persistIfExecutionActive(task.id, execution, {
                         ...baseUpdate,
-                        status: "completed",
-                        waitingReason: null,
-                        nextCheckAt: null,
-                        completedAt: referenceAt,
-                        lastAutomationAt: referenceAt,
-                        lastAutomationSummary: evaluation.summary
-                    }, {
-                        kind: "completed",
-                        status: "completed",
-                        summary: evaluation.summary,
+                        status: "active",
                         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,
+                        nextCheckAt: resolveProviderUsageLimitNextCheckAt(providerUsageLimit, referenceAt, task.checkIntervalSeconds),
                         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
+                        lastAutomationSummary: buildFollowUpUsageLimitSummary(providerUsageLimit, "跟进助手会话当前被 provider 额度限制暂时挡住。")
                     });
-                case "continue":
-                    if (!evaluation.continuePrompt) {
-                        return this.persistWithRound({
-                            ...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
-                        });
-                    }
-                    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({
+                }
+                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) {
@@ -440,6 +570,16 @@ export class ButlerFollowUpService {
         }
         return this.butlerFollowUpTaskRepository.update(normalizedTask) ?? normalizedTask;
     }
+    requireAssistantDecisionPersisted(taskId, before) {
+        const updated = this.butlerFollowUpTaskRepository.findById(taskId);
+        if (!updated) {
+            throw new Error("跟进任务在回写结果前已丢失");
+        }
+        if (!hasTaskProgressAdvanced(updated, before)) {
+            throw new Error("跟进助手没有通过 follow-ups 命令回写本轮结果");
+        }
+        return updated;
+    }
     persistWithRound(task, round) {
         const normalizedRounds = normalizeFollowUpRounds(task.rounds);
         return this.persist({
@@ -447,6 +587,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();
@@ -497,7 +649,7 @@ export class ButlerFollowUpService {
             && normalizeNullableIso(session.lastMessageAt) === normalizeNullableIso(task.lastObservedMessageAt)
             && session.messageCount === task.lastObservedMessageCount);
     }
-    async sendContinuePrompt(task, continuePrompt, referenceAt) {
+    async sendContinuePrompt(task, providerId, continuePrompt, referenceAt) {
         const clientRequestId = buildFollowUpClientRequestId(task.id, referenceAt);
         try {
             const result = await this.sessionLiveRuntimeService.sendLiveMessage({
@@ -518,6 +670,13 @@ export class ButlerFollowUpService {
             };
         }
         catch (error) {
+            const providerUsageLimit = resolveProviderUsageLimitFromError(error, providerId, referenceAt);
+            if (providerUsageLimit) {
+                return {
+                    delivery: "cooldown",
+                    providerUsageLimit
+                };
+            }
             if (!isDeferredFollowUpSendError(error)) {
                 throw error;
             }
@@ -553,32 +712,36 @@ export class ButlerFollowUpService {
         });
     }
     async inspectTask(task) {
-        const session = this.sessionHistoryService.getSession(task.sessionId, task.createdByUserId);
-        const runtime = await this.sessionLiveRuntimeService.getSessionRuntime(task.sessionId, task.createdByUserId);
-        const envelope = await this.sessionHistoryService.readRecentHistoryEnvelope(task.sessionId, RECENT_HISTORY_LIMIT);
+        return this.inspectSession(task.sessionId, task.createdByUserId);
+    }
+    async inspectSession(sessionId, userId) {
+        const session = this.sessionHistoryService.getSession(sessionId, userId);
+        const runtime = await this.sessionLiveRuntimeService.getSessionRuntime(sessionId, userId);
+        const envelope = await this.sessionHistoryService.readRecentHistoryEnvelope(sessionId, RECENT_HISTORY_LIMIT);
+        const latestAssistantText = resolveLatestAssistantText(envelope);
         const sortedMessages = (envelope?.messages ?? [])
             .slice()
             .sort((left, right) => left.sequence - right.sequence);
+        const providerUsageLimit = resolveInspectionProviderUsageLimit(session.provider, session.lastErrorDetail, latestAssistantText, session.lastMessageAt);
         return {
+            providerId: session.provider,
             runningState: normalizeRunningState(runtime.runningState),
             messageAt: session.lastMessageAt,
             messageCount: session.messageCount,
             sessionTitle: session.title ?? null,
-            latestAssistantText: resolveLatestAssistantText(envelope),
+            providerUsageLimit,
+            latestAssistantText,
             transcriptLines: sortedMessages.map((message) => renderHistoryLine(message.sequence, message.role, message.kind ?? "text", message.timestamp, message.content))
         };
     }
-    async evaluateTask(profile, project, task, inspection, runningState) {
-        const evaluatorWorkspacePath = path.join(profile.workspacePath, FOLLOW_UP_EVALUATOR_DIRNAME);
-        ensureButlerWorkspaceIsolation(evaluatorWorkspacePath);
-        this.writeEvaluationInstructionFiles(evaluatorWorkspacePath, profile.providerId);
-        this.syncCodexInstructionConfig(profile.providerId, evaluatorWorkspacePath);
-        const workspace = this.workspaceService.importWorkspace(evaluatorWorkspacePath, "代码助手");
+    async requestAssistantEvaluation(project, task, inspection, runningState, execution) {
         const instruction = this.instructionAdapter.buildInstruction({
-            providerId: profile.providerId,
+            taskId: task.id,
+            providerId: task.providerId,
             project,
             sessionId: task.sessionId,
             butlerSessionId: task.butlerSessionId,
+            assistantSessionId: task.assistantSessionId,
             sessionTitle: inspection.sessionTitle,
             objective: task.objective,
             completionCriteria: task.completionCriteria,
@@ -591,56 +754,82 @@ export class ButlerFollowUpService {
             latestAssistantText: inspection.latestAssistantText,
             transcriptLines: inspection.transcriptLines
         });
-        const adapter = this.providerAdapterRegistry.get(profile.providerId);
-        const launch = await adapter.startPatrolSession({
-            workspaceId: workspace.id,
-            userId: task.createdByUserId,
-            providerId: profile.providerId,
-            prompt: instruction.prompt,
-            model: resolveFollowUpModel(profile.providerId, this.sourceCodexHomeDir),
-            reasoningLevel: "low",
-            permissionMode: "default"
-        });
-        await adapter.waitForSessionTerminal(launch.sessionId);
-        const result = await adapter.readPatrolResult(launch.sessionId);
-        return parseEvaluationResult(result);
-    }
-    writeEvaluationInstructionFiles(workspacePath, providerId) {
-        const content = [
-            "# 代码助手后台跟进评估规则",
-            "",
-            "你不是普通项目会话，也不是面向用户的聊天助手。",
-            "你的身份是后台跟进评估器，只负责判断某个开发会话现在该继续推进、等用户决定、还是已经完成。",
-            "如果目标或上下文里提到了 spec，完成标准只能按 spec 明确要求的必做项判断。",
-            "“建议下一步”“最佳实践”“可以顺手优化”这类内容默认都不是必做项，不能据此继续扩范围。",
-            "如果没有 spec，就先从目标和最近消息里归纳一句当前核心任务，后续只能围绕这个核心任务判断，不准无限扩展。",
-            "除非目标本身要求，否则不要把重构、补测试、补体验优化之类建议项升级成必须开发的工作。",
-            "禁止照搬最后一句回复做草率判断，必须结合用户目标、当前运行态和最近消息一起判断。",
-            "如果能继续推进，就直接给出下一条要发给开发会话的中文指令，不要空谈。",
-            "如果确实需要用户决定，要把缺口说清楚，但不要替用户做不存在的决定。",
-            "输出语言必须是中文，先给结论，再给结构化 JSON。"
-        ].join("\n");
-        writeFileIfChanged(path.join(workspacePath, "AGENTS.md"), `${content}\n`);
-        if (providerId === "claude-code") {
-            writeFileIfChanged(path.join(workspacePath, "CLAUDE.md"), `${content}\n`);
-        }
-    }
-    syncCodexInstructionConfig(providerId, workspacePath) {
-        if (providerId !== "codex" || !this.followUpCodexHomeDir?.trim()) {
+        execution.assistantSessionId = task.assistantSessionId;
+        try {
+            await this.waitForAssistantSessionTerminal(task.assistantSessionId, task.createdByUserId);
+            this.ensureTaskExecutionActive(task.id, execution);
+            await this.sessionLiveRuntimeService.sendLiveMessage({
+                sessionId: task.assistantSessionId,
+                userId: task.createdByUserId,
+                content: instruction.prompt,
+                clientRequestId: null,
+                runtimeOptions: {
+                    model: resolveFollowUpModel(task.providerId, this.sourceCodexHomeDir),
+                    reasoningLevel: "low",
+                    permissionMode: "default",
+                    attachments: []
+                }
+            });
+            await this.waitForAssistantSessionTerminal(task.assistantSessionId, task.createdByUserId);
+            this.ensureTaskExecutionActive(task.id, execution);
+        }
+        finally {
+            if (execution.assistantSessionId === task.assistantSessionId) {
+                execution.assistantSessionId = null;
+            }
+        }
+    }
+    beginTaskExecution(taskId) {
+        const execution = {
+            cancelled: false,
+            assistantSessionId: 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(task, execution) {
+        if (!execution?.assistantSessionId) {
             return;
         }
-        const targetHomeDir = path.resolve(this.followUpCodexHomeDir);
-        const sourceHomeDir = resolveSourceCodexHomeDir(this.sourceCodexHomeDir, targetHomeDir);
-        const sourceConfigPath = path.join(sourceHomeDir, "config.toml");
-        const sourceConfigContent = sourceHomeDir !== targetHomeDir && fs.existsSync(sourceConfigPath) && fs.statSync(sourceConfigPath).isFile()
-            ? fs.readFileSync(sourceConfigPath, "utf8")
-            : "";
-        const instructionFilePath = path.join(workspacePath, "AGENTS.md");
-        fs.mkdirSync(targetHomeDir, { recursive: true });
-        removeFileIfExists(path.join(targetHomeDir, "AGENTS.md"));
-        removeFileIfExists(path.join(targetHomeDir, "AGENTS.override.md"));
-        syncOptionalFile(path.join(sourceHomeDir, "auth.json"), path.join(targetHomeDir, "auth.json"));
-        writeFileIfChanged(path.join(targetHomeDir, "config.toml"), `${composeCodexConfigContent(sourceConfigContent, instructionFilePath)}\n`);
+        try {
+            await this.sessionLiveRuntimeService.interruptSession(execution.assistantSessionId, task.createdByUserId);
+        }
+        catch (error) {
+            console.warn("[butler-follow-up] interrupt assistant follow-up session failed", {
+                sessionId: execution.assistantSessionId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        finally {
+            execution.assistantSessionId = null;
+        }
+    }
+    async waitForAssistantSessionTerminal(sessionId, userId) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < FOLLOW_UP_ASSISTANT_WAIT_TIMEOUT_MS) {
+            const runtime = await this.sessionLiveRuntimeService.getSessionRuntime(sessionId, userId);
+            if (isAssistantTerminalRuntimeState(runtime.runningState)) {
+                return;
+            }
+            await delay(FOLLOW_UP_ASSISTANT_WAIT_POLL_INTERVAL_MS);
+        }
+        throw new Error(`BUTLER_FOLLOW_UP_ASSISTANT_WAIT_TIMEOUT:${sessionId}`);
     }
 }
 function mapTaskView(task, workspaceId, projectName, sessionTitle) {
@@ -652,6 +841,9 @@ function mapTaskView(task, workspaceId, projectName, sessionTitle) {
         workspaceId,
         butlerSessionId: task.butlerSessionId,
         sessionId: task.sessionId,
+        providerId: task.providerId,
+        assistantButlerSessionId: task.assistantButlerSessionId,
+        assistantSessionId: task.assistantSessionId,
         sessionTitle,
         objective: task.objective,
         completionCriteria: task.completionCriteria,
@@ -729,6 +921,24 @@ function normalizeObjective(value) {
     }
     return normalized;
 }
+function normalizeFollowUpProviderId(value) {
+    switch (value) {
+        case undefined:
+        case null:
+        case "":
+            return "codex";
+        case "codex":
+        case "claude-code":
+            return value;
+        default:
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "INVALID_INPUT",
+                detail: "会话跟进只允许选择 Codex 或 Claude Code",
+                field: "providerId"
+            });
+    }
+}
 function normalizeCompletionCriteria(value, objective) {
     const normalized = value?.trim();
     return normalized && normalized.length > 0
@@ -754,6 +964,16 @@ function buildFollowUpClientRequestId(taskId, referenceAt) {
 function buildQueuedFollowUpSummary(summary, queueItem) {
     return `${summary} 已转入消息队列，等待当前会话空闲后自动补发（队列项 ${queueItem.orderIndex}）。`;
 }
+function buildFollowUpUsageLimitSummary(providerUsageLimit, prefix) {
+    return `${prefix} ${providerUsageLimit.summary}`;
+}
+function resolveProviderUsageLimitNextCheckAt(providerUsageLimit, referenceAt, fallbackSeconds) {
+    const blockedUntil = resolveProviderUsageLimitBlockedUntil(providerUsageLimit, referenceAt);
+    if (blockedUntil && Date.parse(blockedUntil) > Date.parse(referenceAt)) {
+        return blockedUntil;
+    }
+    return shiftSeconds(referenceAt, fallbackSeconds);
+}
 function isDeferredFollowUpSendError(error) {
     if (error instanceof AppError) {
         return (error.errorCode === "ACTIVE_RUN_EXISTS"
@@ -775,6 +995,14 @@ function isDeferredFollowUpSendError(error) {
         || error.message === "SERVER_TIMEOUT"
         || error.message.includes("当前会话正在运行"));
 }
+function isAssistantTerminalRuntimeState(state) {
+    return state === "idle" || state === "completed" || state === "failed" || state === "interrupted";
+}
+function delay(timeoutMs) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeoutMs);
+    });
+}
 function isSyntheticMessageId(messageId) {
     return typeof messageId === "string" && messageId.startsWith("synthetic-");
 }
@@ -802,6 +1030,24 @@ function normalizeNullableIso(value) {
     const normalized = value?.trim();
     return normalized && normalized.length > 0 ? normalized : null;
 }
+function resolveInspectionProviderUsageLimit(providerId, lastErrorDetail, latestAssistantText, referenceAt) {
+    const normalizedReferenceAt = normalizeNullableIso(referenceAt) ?? undefined;
+    const fromErrorDetail = normalizeProviderUsageLimit({
+        providerId,
+        text: lastErrorDetail,
+        referenceAt: normalizedReferenceAt,
+        source: "error_detail"
+    });
+    if (fromErrorDetail) {
+        return fromErrorDetail;
+    }
+    return normalizeProviderUsageLimit({
+        providerId,
+        text: latestAssistantText,
+        referenceAt: normalizedReferenceAt,
+        source: "message"
+    });
+}
 function resolveLatestAssistantText(envelope) {
     if (!envelope || envelope.messages.length === 0) {
         return null;
@@ -823,140 +1069,91 @@ function truncateText(value, maxLength) {
     }
     return `${value.slice(0, Math.max(0, maxLength - 1))}…`;
 }
+function buildFollowUpBootstrapPrompt(input) {
+    const transcript = input.transcriptLines.length > 0
+        ? input.transcriptLines.slice(-12).join("\n")
+        : "- 暂时没有可用消息，请先按会话现状建立上下文。";
+    return [
+        "你现在是这条开发会话的专用跟进助手，会长期复用当前助手会话推进，不再切回隐藏评估器。",
+        "你的职责只有三件事：",
+        "1. 用 codingns assistant CLI 复核目标项目和目标会话的最新状态。",
+        "2. 判断当前是否真的还需要继续跟进，还是应该等待用户决定，或者已经可以结束。",
+        "3. 用 codingns assistant sessions send 和 codingns assistant follow-ups.* 自己完成发消息与任务回写，不要等后台代发或猜结果。",
+        "",
+        "硬约束：",
+        "- 不要直接改当前仓库代码，这条会话只负责跟进判断和向目标开发会话发消息。",
+        "- 如果决定继续，必须显式使用 `codingns assistant sessions send` 把中文跟进消息发到目标开发会话。",
+        "- 每一轮正式结论都必须用 `codingns assistant follow-ups continue|waiting-user|complete|fail` 之一回写到跟进任务。",
+        "- 如果信息不足或需要用户决策，要明确说明缺口，不要假装已经发消息。",
+        "- 跟进边界只围绕当前目标和结束条件，不准顺手扩范围。",
+        "",
+        `项目名称：${input.project.name}`,
+        `项目路径：${input.project.repoRoot}`,
+        `目标 Butler 会话 ID：${input.sourceButlerSessionId}`,
+        `目标真实会话 ID：${input.sourceSessionId}`,
+        `目标会话标题：${input.sourceSessionTitle ?? "未命名会话"}`,
+        `跟进目标：${input.objective}`,
+        `结束条件：${input.completionCriteria}`,
+        `最多自动推进轮数：${input.maxAutoContinueCount}`,
+        `最近一条助手消息：${input.latestAssistantText?.trim() || "无"}`,
+        "",
+        "最近消息摘录：",
+        transcript,
+        "",
+        "这条消息只用来建立上下文。请先整理当前理解，后续我会继续给你发送正式的跟进检查请求。"
+    ].join("\n");
+}
 function resolveFollowUpModel(providerId, sourceCodexHomeDir) {
     if (providerId !== "codex") {
         return "haiku";
     }
     return resolveButlerCodexBackgroundModel("gpt-5.1-codex-mini", sourceCodexHomeDir);
 }
-function parseEvaluationResult(result) {
-    const rawJson = result.structured.rawJson ?? extractJsonFromText(result.latestAssistantMessage);
-    if (!rawJson) {
-        throw new Error("后台评估助手没有返回结构化 JSON");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawJson);
-    }
-    catch (error) {
-        throw new Error(`后台评估助手返回的 JSON 无法解析：${error instanceof Error ? error.message : String(error)}`);
-    }
-    const decision = normalizeDecision(parsed.decision);
-    if (!decision) {
-        throw new Error("后台评估助手返回的 decision 不合法");
-    }
-    const summary = normalizeNonEmptyString(parsed.summary) ?? result.structured.summary ?? "后台评估助手未提供摘要";
-    const waitingReason = normalizeNullableString(parsed.waitingReason);
-    const continuePrompt = normalizeNullableString(parsed.continuePrompt);
-    const riskLevel = normalizeRiskLevel(parsed.riskLevel);
+function snapshotTaskProgress(task) {
     return {
-        decision,
-        summary,
-        waitingReason,
-        continuePrompt,
-        riskLevel
+        roundCount: normalizeFollowUpRounds(task.rounds).length,
+        updatedAt: task.updatedAt,
+        lastAutomationAt: task.lastAutomationAt,
+        autoContinueCount: task.autoContinueCount
     };
 }
-function normalizeDecision(value) {
-    switch (value) {
-        case "continue":
-        case "waiting_user":
-        case "completed":
-        case "failed":
-            return value;
-        default:
-            return null;
-    }
+function hasTaskProgressAdvanced(task, before) {
+    const roundCount = normalizeFollowUpRounds(task.rounds).length;
+    return (roundCount > before.roundCount
+        || task.updatedAt !== before.updatedAt
+        || task.lastAutomationAt !== before.lastAutomationAt
+        || task.autoContinueCount !== before.autoContinueCount);
 }
-function normalizeRiskLevel(value) {
-    switch (value) {
-        case "low":
-        case "medium":
-        case "high":
-            return value;
-        default:
-            return null;
-    }
-}
-function normalizeNonEmptyString(value) {
+function requireNonEmptyFollowUpText(value, field, detail) {
     if (typeof value !== "string") {
-        return null;
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "BUTLER_FOLLOW_UP_TASK_INVALID_INPUT",
+            detail
+        });
     }
     const normalized = value.trim();
-    return normalized || null;
-}
-function normalizeNullableString(value) {
-    if (value === null || value === undefined) {
-        return null;
-    }
-    return normalizeNonEmptyString(value);
-}
-function extractJsonFromText(value) {
-    if (!value) {
-        return null;
-    }
-    const matched = value.match(/```json\s*([\s\S]*?)```/i);
-    const raw = matched?.[1]?.trim();
-    return raw || null;
-}
-function resolveSourceCodexHomeDir(sourceCodexHomeDir, targetHomeDir) {
-    const configuredSource = sourceCodexHomeDir?.trim();
-    if (configuredSource) {
-        const resolvedConfiguredSource = path.resolve(configuredSource);
-        if (resolvedConfiguredSource !== targetHomeDir) {
-            return resolvedConfiguredSource;
-        }
-    }
-    const fallbackHomeDir = path.resolve(path.join(os.homedir(), ".codex"));
-    if (fallbackHomeDir !== targetHomeDir) {
-        return fallbackHomeDir;
-    }
-    return targetHomeDir;
-}
-function composeCodexConfigContent(sourceConfigContent, instructionFilePath) {
-    const normalizedSource = sourceConfigContent
-        .split(/\r?\n/)
-        .filter((line) => {
-        const trimmed = line.trim();
-        return trimmed.length > 0 && !trimmed.startsWith("model_instructions_file");
-    })
-        .join("\n")
-        .trim();
-    return [
-        "# 代码助手跟进评估专用 Codex 配置（系统自动生成）",
-        normalizedSource,
-        `model_instructions_file = ${toTomlString(path.resolve(instructionFilePath))}`
-    ]
-        .filter((part) => part.trim().length > 0)
-        .join("\n\n");
-}
-function toTomlString(value) {
-    return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
-}
-function writeFileIfChanged(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    if (fs.existsSync(filePath) && fs.readFileSync(filePath, "utf8") === content) {
-        return;
-    }
-    fs.writeFileSync(filePath, content, "utf8");
-}
-function removeFileIfExists(filePath) {
-    if (!fs.existsSync(filePath)) {
-        return;
+    if (!normalized) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "BUTLER_FOLLOW_UP_TASK_INVALID_INPUT",
+            detail
+        });
     }
-    if (fs.statSync(filePath).isFile()) {
-        fs.rmSync(filePath, { force: true });
+    if (normalized.length > 4000) {
+        throw new AppError({
+            statusCode: 400,
+            errorCode: "BUTLER_FOLLOW_UP_TASK_INVALID_INPUT",
+            detail: `${field} 长度不能超过 4000 个字符`
+        });
     }
+    return normalized;
 }
-function syncOptionalFile(sourcePath, targetPath) {
-    if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
-        removeFileIfExists(targetPath);
-        return;
-    }
-    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-    if (fs.existsSync(targetPath) && fs.readFileSync(targetPath).equals(fs.readFileSync(sourcePath))) {
-        return;
+function normalizeNullableText(value) {
+    if (typeof value !== "string") {
+        return null;
     }
-    fs.copyFileSync(sourcePath, targetPath);
+    const normalized = value.trim();
+    return normalized || null;
 }
 //# sourceMappingURL=butler-follow-up-service.js.map