vibe-coding-master 0.6.1 → 0.6.3

package/dist/backend/gateway/gateway-service.js

@@ -13,6 +13,8 @@ const POLL_LONG_BACKOFF_MS = 30_000;
 const MAX_FAILURES_BEFORE_LONG_BACKOFF = 3;
 const DEFAULT_POLL_TIMEOUT_MS = 35_000;
 const LARK_REGISTRATION_CONFIRM_TIMEOUT_MS = 15_000;
+const GATEWAY_ROUND_FINAL_WAIT_MS = 12_000;
+const GATEWAY_ROUND_FINAL_POLL_MS = 250;
 const GATEWAY_TRANSLATION_FAILURE_TEXT = "PM 回复已收到，但翻译失败。\n发送 /retry 重新翻译。";
 const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
     "help",
@@ -21,6 +23,8 @@ const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
     "projects",
     "tasks"
 ]);
+class HandledGatewayInboundError extends Error {
+}
 export function createGatewayService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const larkRegistration = deps.larkRegistration ?? createLarkRegistrationClient();
@@ -219,6 +223,10 @@ export function createGatewayService(deps) {
             return;
         }
         const command = parseGatewayCommand(update.text);
+        if (command.kind === "plain" && settings.enabled) {
+            await handlePlainInbound(update, command.text);
+            return;
+        }
         try {
             const output = await executeCommand(command, settings);
             await reply(await deps.settings.loadSettings(), update.fromUserId, output);
@@ -247,6 +255,69 @@ export function createGatewayService(deps) {
             });
         }
     }
+    async function handlePlainInbound(update, text) {
+        try {
+            const target = await resolvePlainTextPmTarget(text);
+            if (typeof target === "string") {
+                await reply(await deps.settings.loadSettings(), update.fromUserId, target);
+                await recordInbound(update, "ok", "plain");
+                return;
+            }
+            if (target.settings.translationEnabled) {
+                await reply(await deps.settings.loadSettings(), update.fromUserId, "已收到，正在翻译...");
+            }
+            else {
+                await reply(await deps.settings.loadSettings(), update.fromUserId, "已收到，正在发送给 PM...");
+            }
+            const englishText = target.settings.translationEnabled
+                ? await translatePlainTextForPm(target, text, update)
+                : text;
+            await submitTerminalInput(deps.runtime, target.session.id, englishText);
+            await reply(await deps.settings.loadSettings(), update.fromUserId, target.settings.translationEnabled
+                ? formatGatewayInputTranslationSuccess(englishText)
+                : "已发送给 PM。");
+            await recordInbound(update, "ok", "plain");
+        }
+        catch (error) {
+            if (error instanceof HandledGatewayInboundError) {
+                return;
+            }
+            const message = errorMessage(error);
+            await reply(await deps.settings.loadSettings(), update.fromUserId, `Error: ${message}`);
+            await recordInbound(update, "error", "plain", message);
+        }
+    }
+    async function translatePlainTextForPm(target, text, update) {
+        try {
+            return (await deps.translationService.translateUserInput({
+                repoRoot: target.project.repoRoot,
+                taskRepoRoot: getTaskRuntimeRepoRoot(target.task),
+                taskSlug: target.task.taskSlug,
+                role: "project-manager",
+                text,
+                useContext: false,
+                send: false
+            })).englishPreview;
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            await reply(await deps.settings.loadSettings(), update.fromUserId, formatGatewayInputTranslationFailure(message));
+            await recordInbound(update, "error", "plain", message);
+            throw new HandledGatewayInboundError();
+        }
+    }
+    async function recordInbound(update, result, command, error) {
+        await recordMessageStatus("inbound", result, update.text, error, command);
+        await deps.audit.record({
+            type: "gateway.command",
+            result,
+            messageId: update.messageId,
+            userId: update.fromUserId,
+            command,
+            preview: update.text,
+            error
+        });
+    }
     async function saveInboundMetadata(settings, update, options = {}) {
         const bindMode = options.bind ?? "never";
         return deps.settings.saveSettings({
@@ -594,12 +665,15 @@ export function createGatewayService(deps) {
     }
     async function enableGatewayTranslationRuntime() {
         const preferences = await deps.appSettings.getPreferences();
-        if (preferences.translationEnabled && preferences.translationAutoSendEnabled) {
+        if (preferences.translationEnabled &&
+            preferences.translationAutoSendEnabled &&
+            preferences.translationOutputMode === "round-final") {
             return;
         }
         await deps.appSettings.updatePreferences({
             translationEnabled: true,
-            translationAutoSendEnabled: true
+            translationAutoSendEnabled: true,
+            translationOutputMode: "round-final"
         });
     }
     async function startGateway() {
@@ -633,6 +707,25 @@ export function createGatewayService(deps) {
         return lines.join("\n");
     }
     async function sendPlainTextToPm(text) {
+        const target = await resolvePlainTextPmTarget(text);
+        if (typeof target === "string") {
+            return target;
+        }
+        const englishText = target.settings.translationEnabled
+            ? (await deps.translationService.translateUserInput({
+                repoRoot: target.project.repoRoot,
+                taskRepoRoot: getTaskRuntimeRepoRoot(target.task),
+                taskSlug: target.task.taskSlug,
+                role: "project-manager",
+                text,
+                useContext: false,
+                send: false
+            })).englishPreview
+            : text;
+        await submitTerminalInput(deps.runtime, target.session.id, englishText);
+        return "Sent to PM.";
+    }
+    async function resolvePlainTextPmTarget(text) {
         if (!text.trim()) {
             return "Empty message ignored.";
         }
@@ -657,21 +750,13 @@ export function createGatewayService(deps) {
         if (session.activityStatus === "running") {
             return "PM is still working on the current turn. Please wait and send again later.";
         }
-        const englishText = settings.translationEnabled
-            ? (await deps.translationService.translateUserInput({
-                repoRoot: project.repoRoot,
-                taskRepoRoot: getTaskRuntimeRepoRoot(task),
-                taskSlug: task.taskSlug,
-                role: "project-manager",
-                text,
-                useContext: false,
-                send: false
-            })).englishPreview
-            : text;
-        await submitTerminalInput(deps.runtime, session.id, englishText);
-        return "Sent to PM.";
+        return { project, task, session, settings };
     }
     async function reply(settings, userId, text) {
+        await sendGatewayText(settings, userId, text);
+        await recordMessageStatus("outbound", "ok", text);
+    }
+    async function sendGatewayText(settings, userId, text) {
         const account = toAccount(settings);
         if (!account) {
             return;
@@ -685,7 +770,6 @@ export function createGatewayService(deps) {
             contextToken,
             text
         });
-        await recordMessageStatus("outbound", "ok", text);
     }
     async function recordMessageStatus(direction, result, preview, error, command) {
         const settings = await deps.settings.loadSettings();
@@ -1032,19 +1116,12 @@ export function createGatewayService(deps) {
                 return;
             }
             const events = await readTranscriptTextEvents(transcriptPath);
-            const latestReply = selectLatestTurnReply(events, input.session);
-            if (latestReply) {
-                await saveLatestPmReply(input, latestReply);
-            }
-            const settings = await deps.settings.loadSettings();
-            const account = toAccount(settings);
-            const boundUserId = settings.binding.boundUserId;
-            // A disarmed gateway never touches the channel: skip the outbound push.
-            // The latest reply was already cached above and replays on the next /start.
-            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
+            const round = await waitForGatewayRoundFinal(input.repoRoot, input.taskSlug);
+            if (!round) {
                 return;
             }
             const cursorKey = `${input.taskSlug}:project-manager:${input.session.claudeSessionId}`;
+            const settings = await deps.settings.loadSettings();
             const cursor = settings.pushCursors[cursorKey];
             const nextEvents = selectEventsAfterCursor(events, cursor?.lastTranscriptEventId)
                 .filter(isFinalTurnTextEvent);
@@ -1055,19 +1132,36 @@ export function createGatewayService(deps) {
             if (!text) {
                 return;
             }
-            const output = await renderGatewayPmOutput({
-                settings,
-                repoRoot: input.repoRoot,
-                taskSlug: input.taskSlug,
-                sourceText: text
-            });
-            await resolveChannel(settings).sendText({
-                account,
-                toUserId: boundUserId,
-                chatId: settings.binding.chatIds[boundUserId] ?? settings.binding.homeChatId ?? undefined,
-                contextToken: settings.binding.contextTokens[boundUserId],
-                text: output.text
-            });
+            const latestReply = selectLatestTurnReply(nextEvents, input.session);
+            if (latestReply) {
+                await saveLatestPmReply(input, latestReply);
+            }
+            const account = toAccount(settings);
+            const boundUserId = settings.binding.boundUserId;
+            // A disarmed gateway never touches the channel: skip the outbound push.
+            // The round-final PM reply was already cached above and replays on the next /start.
+            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
+                return;
+            }
+            const roundNotice = formatGatewayRoundNotice(round);
+            const originalMessage = formatGatewayPmOriginalReply(text, roundNotice);
+            await sendGatewayText(settings, boundUserId, originalMessage);
+            let output;
+            if (settings.translationEnabled) {
+                output = await renderGatewayPmOutput({
+                    settings,
+                    repoRoot: input.repoRoot,
+                    taskSlug: input.taskSlug,
+                    sourceText: text,
+                    sourceEntryIds: nextEvents.map((event) => event.id)
+                });
+                await sendGatewayText(settings, boundUserId, output.translationFailed
+                    ? formatGatewayPmTranslationFailure(output.translationError)
+                    : formatGatewayPmTranslatedReply(output.text));
+            }
+            else {
+                clearFailedTranslation(input.repoRoot, input.taskSlug);
+            }
             const lastEvent = nextEvents.at(-1);
             const current = await deps.settings.loadSettings();
             await deps.settings.saveSettings({
@@ -1082,19 +1176,53 @@ export function createGatewayService(deps) {
                 lastMessageStatus: {
                     checkedAt: now(),
                     direction: "outbound",
-                    result: output.translationFailed ? "error" : "ok",
+                    result: output?.translationFailed ? "error" : "ok",
                     command: "pm-stop",
-                    preview: output.text.slice(0, 160),
-                    error: output.translationError
+                    preview: (output?.text ?? originalMessage).slice(0, 160),
+                    error: output?.translationError
                 },
                 updatedAt: now()
             });
             await deps.audit.record({
                 type: "gateway.pm_push",
-                result: output.translationFailed ? "error" : "ok",
+                result: output?.translationFailed ? "error" : "ok",
                 command: "pm-stop",
-                preview: output.text,
-                error: output.translationError
+                preview: output ? `${originalMessage}\n\n${output.text}` : originalMessage,
+                error: output?.translationError
+            });
+        },
+        async handleRoleStopFailure(input) {
+            const round = await getGatewayRoundState(input.repoRoot, input.taskSlug);
+            if (round?.stopReason === "manual-interrupt") {
+                return;
+            }
+            const settings = await deps.settings.loadSettings();
+            const account = toAccount(settings);
+            const boundUserId = settings.binding.boundUserId;
+            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
+                return;
+            }
+            const message = formatGatewayRoleStopFailure(input, round);
+            await sendGatewayText(settings, boundUserId, message);
+            const current = await deps.settings.loadSettings();
+            await deps.settings.saveSettings({
+                ...current,
+                lastMessageStatus: {
+                    checkedAt: now(),
+                    direction: "outbound",
+                    result: "error",
+                    command: "role-stop-failure",
+                    preview: message.slice(0, 160),
+                    error: input.error
+                },
+                updatedAt: now()
+            });
+            await deps.audit.record({
+                type: "gateway.role_stop_failure",
+                result: "error",
+                command: "role-stop-failure",
+                preview: message,
+                error: input.error
             });
         },
         getDiagnostics() {
@@ -1109,12 +1237,122 @@ export function createGatewayService(deps) {
         }
         return settings.latestPmReplies[latestPmReplyKey(settings.currentProjectId, settings.currentTaskSlug)];
     }
+    async function waitForGatewayRoundFinal(repoRoot, taskSlug) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt <= GATEWAY_ROUND_FINAL_WAIT_MS) {
+            const round = await getGatewayRoundState(repoRoot, taskSlug);
+            if (round && isGatewayRoundFinal(round)) {
+                return round;
+            }
+            if (round && isGatewayNonFinalTerminalRound(round)) {
+                return undefined;
+            }
+            await delay(GATEWAY_ROUND_FINAL_POLL_MS);
+        }
+        return undefined;
+    }
+    async function getGatewayRoundState(repoRoot, taskSlug) {
+        try {
+            const [projectConfig, task] = await Promise.all([
+                deps.projectService.loadConfig(repoRoot),
+                deps.taskService.loadTask(repoRoot, taskSlug)
+            ]);
+            const round = await deps.roundService.getSessionRoundState({
+                repoRoot,
+                stateRepoRoot: getTaskRuntimeRepoRoot(task),
+                stateRoot: projectConfig.stateRoot,
+                taskSlug
+            });
+            return round;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function isGatewayRoundFinal(round) {
+        return round.status === "stopped"
+            && Boolean(round.roundId)
+            && !round.stopReason
+            && round.roleRecovery?.status !== "failed"
+            && round.flowPause?.reason !== "role-recovery-failed";
+    }
+    function isGatewayNonFinalTerminalRound(round) {
+        return round.status === "stopped" && (Boolean(round.stopReason) ||
+            round.roleRecovery?.status === "failed" ||
+            round.flowPause?.reason === "role-recovery-failed");
+    }
+    function formatGatewayRoundNotice(round) {
+        const roundLabel = round.roundSequence ? `第 ${round.roundSequence} 轮` : "当前 round";
+        if (round.status === "stopped") {
+            return `${roundLabel}已结束。现在需要你给出下一步指令。`;
+        }
+        const activeRole = round.activeRole ? `，当前角色：${round.activeRole}` : "";
+        return `${roundLabel}运行中${activeRole}。`;
+    }
+    function formatGatewayRoleStopFailure(input, round) {
+        const roundLabel = round?.roundSequence ? `第 ${round.roundSequence} 轮` : "当前 round";
+        const retryLine = input.maxAttempts !== undefined
+            ? `Retry: ${input.attempt ?? 0}/${input.maxAttempts}`
+            : undefined;
+        return [
+            "VCM 角色异常中断，流程已暂停。",
+            `Task: ${input.taskSlug}`,
+            `Role: ${input.role}`,
+            `Round: ${roundLabel}`,
+            input.error ? `Reason: ${input.error}` : undefined,
+            retryLine,
+            input.errorDetails ? `Details: ${truncateGatewayFailureDetails(input.errorDetails)}` : undefined,
+            "",
+            "请在 VCM 中检查状态，或修复问题后继续给出下一步指令。"
+        ].filter((line) => line !== undefined).join("\n");
+    }
+    function truncateGatewayFailureDetails(value) {
+        const trimmed = value.trim();
+        return trimmed.length > 600 ? `${trimmed.slice(0, 600)}...` : trimmed;
+    }
+    function formatGatewayPmOriginalReply(text, roundNotice) {
+        return [
+            "PM final reply 原文：",
+            "",
+            text.trim(),
+            roundNotice ? "" : undefined,
+            roundNotice ? `Round: ${roundNotice}` : undefined
+        ].filter((line) => line !== undefined).join("\n");
+    }
+    function formatGatewayPmTranslatedReply(text) {
+        return [
+            "PM final reply 翻译：",
+            "",
+            text.trim()
+        ].join("\n");
+    }
+    function formatGatewayPmTranslationFailure(error) {
+        return [
+            GATEWAY_TRANSLATION_FAILURE_TEXT,
+            error ? `原因：${error}` : undefined
+        ].filter((line) => line !== undefined).join("\n");
+    }
+    function formatGatewayInputTranslationSuccess(englishText) {
+        return [
+            "翻译完成，已发送给 PM：",
+            "",
+            englishText.trim()
+        ].join("\n");
+    }
+    function formatGatewayInputTranslationFailure(error) {
+        return [
+            "翻译失败，消息未发送给 PM。",
+            `原因：${error}`,
+            "请重新输入后再试。"
+        ].join("\n");
+    }
     async function renderLatestPmReply(settings, reply) {
         const rendered = await renderGatewayPmOutput({
             settings,
             repoRoot: reply.repoRoot,
             taskSlug: reply.taskSlug,
-            sourceText: reply.text
+            sourceText: reply.text,
+            sourceEntryIds: reply.transcriptEventId ? [reply.transcriptEventId] : undefined
         });
         return {
             ...rendered,
@@ -1134,7 +1372,8 @@ export function createGatewayService(deps) {
                 repoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
                 role: "project-manager",
-                text: input.sourceText
+                text: input.sourceText,
+                sourceEntryIds: input.sourceEntryIds
             });
             clearFailedTranslation(input.repoRoot, input.taskSlug);
             return {
@@ -1293,6 +1532,9 @@ function sleep(ms, signal) {
         }, { once: true });
     });
 }
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function normalizeBaseUrl(input, fallback) {
     const trimmed = input.trim();
     if (!trimmed) {

package/dist/backend/server.js

@@ -277,6 +277,7 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService,
         fs,
         projectService,
+        roundService,
         appSettings
     });
     const gatewayChannels = createGatewayChannelRegistry([

package/dist/backend/services/claude-hook-service.js

@@ -241,15 +241,27 @@ export function createClaudeHookService(deps) {
         }
         const failure = parseStopFailureDiagnostic(input.event);
         if (!failure.retryable) {
+            if (await isManualInterruptedStopFailure(context, input.role)) {
+                return recordTurnEnd(input, context, eventName, {
+                    dispatchRouteFiles: false,
+                    notifyGateway: false,
+                    settleGuard: false
+                });
+            }
             await markStopFailureRecoveryFailed(input, context, failure, 0);
             return recordTurnEnd(input, context, eventName, {
                 dispatchRouteFiles: false,
                 notifyGateway: false,
-                settleGuard: false
+                settleGuard: false,
+                gatewayStopFailure: {
+                    ...failure,
+                    attempt: 0,
+                    maxAttempts: MAX_ROLE_RETRY_ATTEMPTS
+                }
             });
         }
-        const retryScheduled = await scheduleStopFailureRetry(input, context, failure);
-        if (retryScheduled) {
+        const retryResult = await scheduleStopFailureRetry(input, context, failure);
+        if (retryResult === "scheduled") {
             return {
                 ok: true,
                 eventName,
@@ -262,7 +274,8 @@ export function createClaudeHookService(deps) {
         return recordTurnEnd(input, context, eventName, {
             dispatchRouteFiles: false,
             notifyGateway: false,
-            settleGuard: false
+            settleGuard: false,
+            ...(retryResult === "manual-interrupt" ? {} : { gatewayStopFailure: failure })
         });
     }
     async function processPostCompactHook(input) {
@@ -344,6 +357,17 @@ export function createClaudeHookService(deps) {
                 session
             }).catch(() => undefined);
         }
+        if (boundToTask && options.gatewayStopFailure) {
+            void deps.gatewayService?.handleRoleStopFailure({
+                repoRoot: context.project.repoRoot,
+                taskSlug: context.taskSlug,
+                role: input.role,
+                error: options.gatewayStopFailure.error,
+                errorDetails: options.gatewayStopFailure.errorDetails,
+                attempt: options.gatewayStopFailure.attempt,
+                maxAttempts: options.gatewayStopFailure.maxAttempts
+            }).catch(() => undefined);
+        }
         const dispatched = options.dispatchRouteFiles
             ? await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput)
             : [];
@@ -370,14 +394,14 @@ export function createClaudeHookService(deps) {
     async function scheduleStopFailureRetry(input, context, failure) {
         const preferences = await deps.appSettings.getPreferences();
         if (!preferences.roleRetryEnabled || !deps.runtime) {
-            return false;
+            return "not-scheduled";
         }
         const stateInput = createRoundStateInput(context);
         const currentRoundState = await deps.roundService.getSessionRoundState(stateInput);
         if (currentRoundState.stopReason === "manual-interrupt"
             && currentRoundState.status === "stopped"
             && currentRoundState.activeRole === input.role) {
-            return false;
+            return "manual-interrupt";
         }
         const previousAttempt = currentRoundState.roleRecovery?.role === input.role &&
             currentRoundState.roleRecovery.status !== "failed"
@@ -388,7 +412,7 @@ export function createClaudeHookService(deps) {
         if (attempt > MAX_ROLE_RETRY_ATTEMPTS) {
             clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
             await markStopFailureRecoveryFailed(input, context, failure, MAX_ROLE_RETRY_ATTEMPTS, timestamp);
-            return false;
+            return "not-scheduled";
         }
         const nextRetryAt = new Date(Date.parse(timestamp) + attempt * ROLE_RETRY_BASE_DELAY_MS).toISOString();
         await deps.roundService.setRoleRecovery({
@@ -408,7 +432,18 @@ export function createClaudeHookService(deps) {
         });
         await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
         scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
-        return true;
+        return "scheduled";
+    }
+    async function isManualInterruptedStopFailure(context, role) {
+        try {
+            const state = await deps.roundService.getSessionRoundState(createRoundStateInput(context));
+            return state.status === "stopped" &&
+                state.stopReason === "manual-interrupt" &&
+                state.activeRole === role;
+        }
+        catch {
+            return false;
+        }
     }
     function scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt) {
         const key = stopFailureRecoveryKey(context.project.repoRoot, context.taskSlug, input.role);
@@ -441,7 +476,15 @@ export function createClaudeHookService(deps) {
             await recordTurnEnd(input, context, "StopFailure", {
                 dispatchRouteFiles: false,
                 notifyGateway: false,
-                settleGuard: false
+                settleGuard: false,
+                gatewayStopFailure: {
+                    error: recovery.error ?? "stop_failure",
+                    errorDetails: recovery.errorDetails,
+                    lastAssistantMessage: recovery.lastAssistantMessage,
+                    retryable: recovery.retryable ?? true,
+                    attempt: recovery.attempt,
+                    maxAttempts: recovery.maxAttempts
+                }
             });
             return;
         }