@tea-agent/loop-agent 0.38.0 → 0.38.2

package/dist/worker/console/chat/routes.js

@@ -17,6 +17,7 @@ import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle, acceptedOperationIdFromResult } from "./session-store.js";
 import { hashChatTurnPayload, projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
+import { projectDeferredTurnSummary, } from "./deferred-turn.js";
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
 import { ResourcePreferencesError, setSkillAutoInvocationPreference, } from "./resource-preferences-store.js";
 import { ComposerDraftStore } from "./composer-draft-store.js";
@@ -51,7 +52,7 @@ function turnSummary(turn) {
 function isTerminalTurnState(state) {
     return state === "settled" || state === "aborted" || state === "failed";
 }
-const DEFAULT_ABORT_WAIT_MS = 8_000;
+const DEFAULT_ABORT_WAIT_MS = 2_500;
 /** Parse Chat's `<epoch>:<seq>` SSE cursor. Legacy `<sessionId>:<seq>` has
  * the same wire shape; its prefix intentionally fails the current process
  * epoch comparison and triggers safe snapshot recovery (M5.1). */
@@ -645,19 +646,195 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
     const composerDraft = await new ComposerDraftStore(deps.appData).get(sessionId);
     const snapshot = deps.events.snapshot(sessionId);
     const lastEvent = snapshot.at(-1);
+    const activeTurn = deps.events.getActiveTurn(sessionId);
     sendJson(res, 200, {
         ok: true,
         eventEpoch: deps.events.epoch(sessionId),
         session: {
             ...record,
             composerDraft,
-            activeTurnId: deps.events.getActiveTurn(sessionId)?.turnId,
+            activeTurnId: activeTurn?.turnId,
+            turnPhase: activeTurn
+                ? activeTurn.abortRequestedAt
+                    ? "stopping"
+                    : "running"
+                : "idle",
         },
         hasBash: true,
         lastEventId: lastEvent?.eventId ?? null,
         lastEventSeq: lastEvent?.seq ?? 0,
     });
 }
+function parseDeferredImages(value) {
+    const parsed = parseChatImages(value);
+    const raw = Array.isArray(value) ? value : [];
+    return parsed.map((image, index) => {
+        const candidate = raw[index];
+        const name = candidate &&
+            typeof candidate === "object" &&
+            typeof candidate.name === "string"
+            ? candidate.name.trim().slice(0, 180)
+            : `image-${index + 1}`;
+        return { ...image, name: name || `image-${index + 1}` };
+    });
+}
+export async function handlePutDeferredTurn(req, res, deps, sessionId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, {
+            ok: false,
+            accepted: false,
+            error: { code: gate.code, message: gate.message },
+        });
+        return;
+    }
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    const clientRequestId = typeof body.clientRequestId === "string" ? body.clientRequestId.trim() : "";
+    const blockedByTurnId = typeof body.blockedByTurnId === "string" ? body.blockedByTurnId.trim() : "";
+    const text = typeof body.text === "string" ? body.text : "";
+    const expectedRevision = typeof body.expectedRevision === "number" &&
+        Number.isSafeInteger(body.expectedRevision) &&
+        body.expectedRevision >= 0
+        ? body.expectedRevision
+        : undefined;
+    let images;
+    try {
+        images = parseDeferredImages(body.images);
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: "INVALID_ATTACHMENT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    const active = deps.events.getActiveTurn(sessionId);
+    if (!active || !active.abortRequestedAt || active.turnId !== blockedByTurnId) {
+        sendJson(res, 409, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: "TURN_NOT_STOPPING",
+                message: "只有仍在停止中的当前 Turn 可以保存停止后发送消息",
+            },
+            activeTurn: active ? turnSummary(active) : null,
+        });
+        return;
+    }
+    const result = await deps.store.putDeferredTurn(sessionId, {
+        clientRequestId,
+        blockedByTurnId,
+        text,
+        images,
+        ...(expectedRevision !== undefined ? { expectedRevision } : {}),
+    });
+    if (!result.ok) {
+        const status = result.code === "NOT_FOUND"
+            ? 404
+            : result.code === "INVALID_INPUT"
+                ? 400
+                : 409;
+        sendJson(res, status, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: result.code,
+                message: result.code === "REVISION_CONFLICT"
+                    ? "待发送消息已在其他页面更新，请使用服务端最新状态"
+                    : result.code === "NOT_REPLACEABLE"
+                        ? "待发送消息已经开始发送，不能再覆盖"
+                        : result.code === "REQUEST_ID_REUSE_CONFLICT"
+                            ? "clientRequestId 已绑定到不同消息"
+                            : "待发送消息无效或会话不存在",
+            },
+            deferredTurn: result.deferredTurn ?? null,
+            summary: projectDeferredTurnSummary(result.deferredTurn),
+        });
+        return;
+    }
+    emitDeferredTurnUpdate(deps, sessionId, blockedByTurnId, result.deferredTurn, result.deferredTurn.revision);
+    sendJson(res, 200, {
+        ok: true,
+        accepted: true,
+        idempotent: result.idempotent,
+        state: result.deferredTurn.state,
+        revision: result.deferredTurn.revision,
+        deferredTurn: result.deferredTurn,
+        summary: projectDeferredTurnSummary(result.deferredTurn),
+    });
+    void dispatchDeferredTurn(deps, sessionId);
+}
+export async function handleDeleteDeferredTurn(req, res, deps, sessionId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, {
+            ok: false,
+            error: { code: gate.code, message: gate.message },
+        });
+        return;
+    }
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    const clientRequestId = typeof body.clientRequestId === "string" ? body.clientRequestId.trim() : "";
+    const expectedRevision = typeof body.expectedRevision === "number" && Number.isSafeInteger(body.expectedRevision)
+        ? body.expectedRevision
+        : -1;
+    const result = await deps.store.deleteDeferredTurn(sessionId, {
+        clientRequestId,
+        expectedRevision,
+    });
+    if (!result.ok) {
+        sendJson(res, result.code === "NOT_FOUND" ? 404 : 409, {
+            ok: false,
+            error: {
+                code: result.code,
+                message: result.code === "NOT_CANCELLABLE"
+                    ? "消息已经开始发送，不能再撤回"
+                    : "待发送消息已变化，请刷新后重试",
+            },
+            deferredTurn: result.deferredTurn ?? null,
+        });
+        return;
+    }
+    const clearedRevision = result.deferredTurn.revision + 1;
+    emitDeferredTurnUpdate(deps, sessionId, result.deferredTurn.blockedByTurnId, undefined, clearedRevision);
+    sendJson(res, 200, {
+        ok: true,
+        cancelled: true,
+        deferredTurn: result.deferredTurn,
+        revision: clearedRevision,
+    });
+}
 /** Lightweight busy-truth endpoint for the client reconcile loop (pi-web
  *  get_state equivalent): exposes the active turn + the latest turn's durable
  *  outcome WITHOUT the full message payload, so the UI can poll it on an
@@ -684,6 +861,14 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
             isCompacting: false,
             isBashRunning: false,
         };
+    const runtimeBusy = Object.values(runtimeFacts).some((value) => value === true);
+    const turnPhase = active
+        ? active.abortRequestedAt
+            ? "stopping"
+            : "running"
+        : runtimeBusy
+            ? "running"
+            : "idle";
     sendJson(res, 200, {
         ok: true,
         state: {
@@ -695,6 +880,8 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
             activeTurn: active ? turnSummary(active) : null,
             latestTurn: latest ? turnSummary(latest) : null,
             runtime: runtimeFacts,
+            turnPhase,
+            deferredTurn: projectDeferredTurnSummary(record.deferredTurn),
         },
     });
 }
@@ -703,10 +890,19 @@ export async function handleListChatSessions(_req, res, deps) {
     sendJson(res, 200, {
         ok: true,
         schemaVersion: 2,
-        sessions: sessions.map((session) => ({
-            ...session,
-            activeTurnId: deps.events.getActiveTurn(session.sessionId)?.turnId,
-        })),
+        sessions: sessions.map((session) => {
+            const active = deps.events.getActiveTurn(session.sessionId);
+            return {
+                ...session,
+                activeTurnId: active?.turnId,
+                turnPhase: active?.abortRequestedAt
+                    ? "stopping"
+                    : active
+                        ? "running"
+                        : "idle",
+                deferredTurn: projectDeferredTurnSummary(session.deferredTurn),
+            };
+        }),
         hasBash: true,
     });
 }
@@ -1057,49 +1253,63 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
  * Pi prompt continues independently of this HTTP response and publishes to the
  * persisted event ring consumed by GET /events.
  */
-export async function handleCreateChatTurn(req, res, deps, sessionId) {
-    const gate = gateMutation(req, deps);
-    if (!gate.ok) {
-        sendJson(res, gate.status, {
-            ok: false,
-            accepted: false,
-            error: { code: gate.code, message: gate.message },
-        });
-        return;
-    }
-    let body;
-    try {
-        body = await readJsonBody(req);
-    }
-    catch (error) {
-        sendJson(res, 400, {
-            ok: false,
-            accepted: false,
-            error: {
-                code: "INVALID_INPUT",
-                message: error instanceof Error ? error.message : String(error),
-            },
-        });
-        return;
-    }
-    const text = typeof body.text === "string" ? body.text.trim() : "";
-    const clientRequestId = typeof body.clientRequestId === "string" && body.clientRequestId.trim()
-        ? body.clientRequestId.trim()
-        : undefined;
+export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPayload) {
+    let text;
+    let clientRequestId;
     let images;
-    try {
-        images = parseChatImages(body.images);
+    if (trustedPayload) {
+        text = trustedPayload.text.trim();
+        clientRequestId = trustedPayload.clientRequestId.trim();
+        images = trustedPayload.images.map(({ type, mimeType, data }) => ({
+            type,
+            mimeType,
+            data,
+        }));
     }
-    catch (error) {
-        sendJson(res, 400, {
-            ok: false,
-            accepted: false,
-            error: {
-                code: "INVALID_ATTACHMENT",
-                message: error instanceof Error ? error.message : String(error),
-            },
-        });
-        return;
+    else {
+        const gate = gateMutation(req, deps);
+        if (!gate.ok) {
+            sendJson(res, gate.status, {
+                ok: false,
+                accepted: false,
+                error: { code: gate.code, message: gate.message },
+            });
+            return;
+        }
+        let body;
+        try {
+            body = await readJsonBody(req);
+        }
+        catch (error) {
+            sendJson(res, 400, {
+                ok: false,
+                accepted: false,
+                error: {
+                    code: "INVALID_INPUT",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+            return;
+        }
+        text = typeof body.text === "string" ? body.text.trim() : "";
+        clientRequestId =
+            typeof body.clientRequestId === "string" && body.clientRequestId.trim()
+                ? body.clientRequestId.trim()
+                : undefined;
+        try {
+            images = parseChatImages(body.images);
+        }
+        catch (error) {
+            sendJson(res, 400, {
+                ok: false,
+                accepted: false,
+                error: {
+                    code: "INVALID_ATTACHMENT",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+            return;
+        }
     }
     if (!text) {
         sendJson(res, 400, {
@@ -1235,7 +1445,8 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
                 text,
                 images,
                 signal: controller.signal,
-                onUserMessagePersisted: (record) => {
+                onUserMessagePersisted: async (record, userMessage) => {
+                    await trustedPayload?.onUserMessagePersisted?.(turn.turnId, userMessage);
                     const users = record.messages.filter((message) => message.role === "user");
                     if (users.length !== 1)
                         return;
@@ -1312,9 +1523,200 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
                 error: terminalError,
             });
             deps.turnExecutions?.clear(sessionId, turn.turnId);
+            void dispatchDeferredTurn(deps, sessionId);
         }
     })();
 }
+function emitDeferredTurnUpdate(deps, sessionId, turnId, deferredTurn, revision) {
+    deps.events.append(sessionId, turnId, {
+        kind: "queue_update",
+        data: {
+            deferredTurn: projectDeferredTurnSummary(deferredTurn),
+            revision,
+        },
+    });
+}
+async function startTrustedChatTurn(deps, sessionId, payload) {
+    let status = 500;
+    let raw = "";
+    const response = {
+        writeHead(code) {
+            status = code;
+            return this;
+        },
+        end(chunk) {
+            if (chunk !== undefined)
+                raw += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+            return this;
+        },
+    };
+    await handleCreateChatTurn({}, response, deps, sessionId, payload);
+    let body = {};
+    try {
+        body = raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        body = {};
+    }
+    return { status, body };
+}
+const deferredDispatchingSessions = new Set();
+/** Dispatch one durable follow-up through the exact normal Turn creation path. */
+export async function dispatchDeferredTurn(deps, sessionId) {
+    if (deferredDispatchingSessions.has(sessionId))
+        return;
+    deferredDispatchingSessions.add(sessionId);
+    try {
+        let record = await deps.store.get(sessionId);
+        let deferred = record?.deferredTurn;
+        if (!deferred)
+            return;
+        if (deferred.state === "accepted")
+            return;
+        if (deferred.state === "failed")
+            return;
+        if (deferred.state === "dispatching") {
+            const existing = deps.events.findTurnByClientRequestId(sessionId, deferred.clientRequestId);
+            if (existing) {
+                const accepted = await deps.store.transitionDeferredTurn(sessionId, {
+                    expectedRevision: deferred.revision,
+                    state: "accepted",
+                    acceptedTurnId: existing.turnId,
+                });
+                if (accepted)
+                    emitDeferredTurnUpdate(deps, sessionId, existing.turnId, accepted, accepted.revision);
+                return;
+            }
+            if (deps.events.getActiveTurn(sessionId))
+                return;
+            const requeued = await deps.store.transitionDeferredTurn(sessionId, {
+                expectedRevision: deferred.revision,
+                state: "queued",
+            });
+            if (!requeued)
+                return;
+            deferred = requeued;
+        }
+        const runtimeFacts = deps.runtime.getSessionBusyFacts?.(sessionId);
+        const runtimeBusy = Boolean(runtimeFacts && Object.values(runtimeFacts).some((value) => value === true));
+        if (deps.events.getActiveTurn(sessionId) || runtimeBusy)
+            return;
+        const claim = await deps.store.claimDeferredTurn(sessionId, deferred.revision);
+        if (!claim.ok)
+            return;
+        deferred = claim.deferredTurn;
+        emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, deferred, deferred.revision);
+        const started = await startTrustedChatTurn(deps, sessionId, {
+            clientRequestId: deferred.clientRequestId,
+            text: deferred.text,
+            images: deferred.images,
+            onUserMessagePersisted: async (turnId, userMessage) => {
+                deps.events.append(sessionId, turnId, {
+                    kind: "user_message",
+                    data: {
+                        clientRequestId: deferred.clientRequestId,
+                        message: {
+                            id: userMessage.id,
+                            text: userMessage.text,
+                            at: userMessage.at,
+                        },
+                    },
+                });
+                const cleared = await deps.store.clearDeferredTurnForRequest(sessionId, deferred.clientRequestId);
+                if (cleared)
+                    emitDeferredTurnUpdate(deps, sessionId, turnId, undefined, cleared.clearedRevision);
+            },
+        });
+        const accepted = started.body.accepted === true;
+        const turn = started.body.turn && typeof started.body.turn === "object"
+            ? started.body.turn
+            : undefined;
+        if (accepted && turn?.turnId) {
+            const next = await deps.store.transitionDeferredTurn(sessionId, {
+                expectedRevision: deferred.revision,
+                state: "accepted",
+                acceptedTurnId: turn.turnId,
+            });
+            if (next)
+                emitDeferredTurnUpdate(deps, sessionId, turn.turnId, next, next.revision);
+            return;
+        }
+        const error = started.body.error && typeof started.body.error === "object"
+            ? started.body.error
+            : {};
+        if (error.code === "TURN_ACTIVE") {
+            const next = await deps.store.transitionDeferredTurn(sessionId, {
+                expectedRevision: deferred.revision,
+                state: "queued",
+            });
+            if (next)
+                emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, next, next.revision);
+            return;
+        }
+        const failed = await deps.store.transitionDeferredTurn(sessionId, {
+            expectedRevision: deferred.revision,
+            state: "failed",
+            lastError: {
+                code: error.code ?? `HTTP_${started.status}`,
+                message: error.message ?? "停止后的消息未能自动发送",
+            },
+        });
+        if (failed)
+            emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, failed, failed.revision);
+    }
+    catch (error) {
+        // Keep fire-and-forget callers safe and make a dispatch failure visible and
+        // recoverable from the composer instead of leaving the slot indefinitely
+        // in an ambiguous queued/dispatching state.
+        try {
+            const current = (await deps.store.get(sessionId))?.deferredTurn;
+            if (current && (current.state === "queued" || current.state === "dispatching")) {
+                const failed = await deps.store.transitionDeferredTurn(sessionId, {
+                    expectedRevision: current.revision,
+                    state: "failed",
+                    lastError: {
+                        code: "DEFERRED_TURN_DISPATCH_FAILED",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                });
+                if (failed)
+                    emitDeferredTurnUpdate(deps, sessionId, failed.blockedByTurnId, failed, failed.revision);
+            }
+        }
+        catch {
+            // The durable store itself is unavailable. Leave the original record in
+            // place so a later Console boot can recover it.
+        }
+    }
+    finally {
+        deferredDispatchingSessions.delete(sessionId);
+    }
+}
+export async function recoverDeferredTurns(deps) {
+    const sessions = await deps.store.list({ includeArchived: false });
+    await Promise.all(sessions
+        .filter((session) => session.deferredTurn
+        ? session.deferredTurn.state === "queued" ||
+            session.deferredTurn.state === "dispatching"
+        : false)
+        .map(async (session) => {
+        const deferred = session.deferredTurn;
+        const active = deps.events.getActiveTurn(session.sessionId);
+        // A process restart cannot retain AbortController ownership. When the
+        // durable blocker was already stopping and no execution owns it now,
+        // close that orphan before dispatching the server-owned follow-up.
+        if (active?.turnId === deferred.blockedByTurnId &&
+            active.abortRequestedAt &&
+            deps.turnExecutions &&
+            !deps.turnExecutions.get(session.sessionId, active.turnId)) {
+            deps.events.setTurnState(session.sessionId, active.turnId, "failed", {
+                code: "CHAT_TURN_OWNER_LOST",
+                message: "turn ownership was lost during Console restart",
+            });
+        }
+        await dispatchDeferredTurn(deps, session.sessionId);
+    }));
+}
 /** Real server-side abort: invokes Pi session.abort via the execution registry. */
 export async function handleAbortChatTurn(req, res, deps, sessionId, turnId) {
     const gate = gateMutation(req, deps);
@@ -1642,16 +2044,27 @@ async function handleChatFiles(res, deps, sessionId, query) {
     if (!(await requireChatSession(res, deps, sessionId)))
         return;
     const q = query.trim().toLowerCase();
-    const files = (await walkRepoFiles(deps.appData.repoRoot, {
+    const walked = await walkRepoFiles(deps.appData.repoRoot, {
         skipSensitive: true,
         maxFiles: 5000,
-    }))
-        .map((entry) => entry.repoRelative)
-        .filter((file) => !isSensitivePath(file) && (!q || file.toLowerCase().includes(q)))
-        .sort((a, b) => a.localeCompare(b))
+        includeDirs: true,
+    });
+    const entries = walked
+        .filter((entry) => !isSensitivePath(entry.repoRelative) &&
+        (!q || entry.repoRelative.toLowerCase().includes(q)))
+        .sort((a, b) => {
+        const aDir = a.repoRelative.endsWith("/");
+        const bDir = b.repoRelative.endsWith("/");
+        if (aDir !== bDir)
+            return aDir ? -1 : 1;
+        return a.repoRelative.localeCompare(b.repoRelative);
+    })
         .slice(0, 50)
-        .map((path) => ({ path }));
-    sendJson(res, 200, { ok: true, files });
+        .map((entry) => ({
+        path: entry.repoRelative,
+        isDir: entry.repoRelative.endsWith("/"),
+    }));
+    sendJson(res, 200, { ok: true, files: entries });
 }
 export async function handleChatCommands(res, deps, sessionId) {
     try {
@@ -3043,6 +3456,15 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleCreateChatTurn(req, res, deps, decodeURIComponent(sessionTurn[1]));
         return true;
     }
+    const deferredTurn = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/deferred-turn$/);
+    if (method === "PUT" && deferredTurn) {
+        await handlePutDeferredTurn(req, res, deps, decodeURIComponent(deferredTurn[1]));
+        return true;
+    }
+    if (method === "DELETE" && deferredTurn) {
+        await handleDeleteDeferredTurn(req, res, deps, decodeURIComponent(deferredTurn[1]));
+        return true;
+    }
     const sessionTurnAbort = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/turns\/([^/]+)\/abort$/);
     if (method === "POST" && sessionTurnAbort) {
         await handleAbortChatTurn(req, res, deps, decodeURIComponent(sessionTurnAbort[1]), decodeURIComponent(sessionTurnAbort[2]));

package/dist/worker/console/chat/semantic-activity.js

@@ -38,10 +38,12 @@ const OPERATION_TITLES = {
     dagStatus: "执行状态",
     dagDoctor: "执行诊断",
     dagReport: "执行结果",
-    dagRerunPlan: "恢复评估",
+    dagRerunPlan: "节点恢复评估",
+    dagRerun: "从失败节点恢复",
     dagInterruptEligibility: "中止资格",
-    standaloneTaskRerun: "恢复执行",
-    workerTaskRetry: "重试任务",
+    standaloneTaskRerun: "带反馈重新执行",
+    workerTaskRetry: "重试 Worker 任务",
+    workerPoolDoctor: "任务池诊断",
     promoteRun: "任务推进",
     status: "任务状态",
 };
@@ -87,19 +89,29 @@ const TOOL_SEMANTICS = {
         error: "读取执行结果时遇到问题",
     },
     dagRerunPlan: {
-        running: "正在评估能否从失败位置继续",
-        success: "恢复条件评估已经完成",
+        running: "正在评估能否从失败节点安全恢复",
+        success: "节点恢复条件评估已经完成",
         error: "暂时无法确定安全的恢复方式",
     },
+    dagRerun: {
+        running: "正在创建节点恢复 run",
+        success: "节点恢复 run 已经启动",
+        error: "从失败节点恢复时遇到问题",
+    },
     dagInterruptEligibility: {
         running: "正在检查能否协作中止此运行",
         success: "中止资格已经确认",
         error: "当前运行不能协作中止",
     },
     standaloneTaskRerun: {
-        running: "正在从失败位置恢复执行",
-        success: "已经从失败位置继续执行",
-        error: "从失败位置恢复执行时遇到问题",
+        running: "正在创建新的完整 DAG，并带入上一轮未解决反馈",
+        success: "新的完整 DAG 已经按上一轮反馈重新执行",
+        error: "带反馈重新执行任务时遇到问题",
+    },
+    workerPoolDoctor: {
+        running: "正在读取任务池状态",
+        success: "任务池状态已经读取",
+        error: "读取任务池状态时遇到问题",
     },
     promoteRun: {
         running: "正在推进任务状态",