vibe-coding-master 0.9.9 → 0.9.10

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

@@ -1346,6 +1346,22 @@ export function createGatewayService(deps) {
     }
     function formatGatewayRoleStopFailure(input, round) {
         const roundLabel = round?.roundSequence ? `第 ${round.roundSequence} 轮` : "当前 round";
+        const claudeMessage = input.lastAssistantMessage && input.lastAssistantMessage !== input.errorDetails
+            ? `Claude Code: ${truncateGatewayFailureDetails(input.lastAssistantMessage)}`
+            : undefined;
+        if (input.usageLimitWait) {
+            return [
+                "Claude 额度已用完，VCM 已暂停该角色，等待额度恢复。",
+                `Task: ${input.taskSlug}`,
+                `Role: ${input.role}`,
+                `Round: ${roundLabel}`,
+                claudeMessage,
+                "",
+                input.usageLimitWait.resetAt
+                    ? "VCM 会在额度恢复约 2 分钟后自动继续，无需操作。"
+                    : "Claude Code 没有给出恢复时间，VCM 每小时自动检查一次，恢复后自动继续。"
+            ].filter((line) => line !== undefined).join("\n");
+        }
         const retryLine = input.maxAttempts !== undefined
             ? `Retry: ${input.attempt ?? 0}/${input.maxAttempts}`
             : undefined;
@@ -1357,6 +1373,7 @@ export function createGatewayService(deps) {
             input.error ? `Reason: ${input.error}` : undefined,
             retryLine,
             input.errorDetails ? `Details: ${truncateGatewayFailureDetails(input.errorDetails)}` : undefined,
+            claudeMessage,
             "",
             "请在 VCM 中检查状态，或修复问题后继续给出下一步指令。"
         ].filter((line) => line !== undefined).join("\n");

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

@@ -5,12 +5,21 @@ import { findPmUserQuestion } from "./pm-user-question.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { matchesRoleHookSession } from "./session-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
+import { detectUsageLimit } from "./usage-limit.js";
 const MAX_ROLE_RETRY_ATTEMPTS = 20;
 const ROLE_RETRY_BASE_DELAY_MS = 60_000;
+// A usage limit waits for its reset time, retried shortly after it; a limit
+// whose reset time is unknown is checked again every hour. Waiting stops after
+// eight days, longer than a weekly limit lasts.
+const USAGE_LIMIT_RESET_BUFFER_MS = 2 * 60_000;
+const USAGE_LIMIT_UNKNOWN_RESET_RETRY_MS = 60 * 60_000;
+const MAX_USAGE_LIMIT_WAIT_MS = 8 * 24 * 60 * 60_000;
 const NON_RETRYABLE_STOP_FAILURE_ERRORS = new Set([
     "authentication_failed",
     "oauth_org_not_allowed",
+    "account_on_hold",
     "billing_error",
+    "cloud_credential_error",
     "invalid_request",
     "model_not_found",
     "max_output_tokens",
@@ -464,7 +473,10 @@ export function createClaudeHookService(deps) {
                 }
             });
         }
-        const retryResult = await scheduleStopFailureRetry(input, context, failure);
+        const usageLimit = detectUsageLimit(failure, new Date(now()));
+        const retryResult = usageLimit
+            ? await scheduleUsageLimitRetry(input, context, failure, usageLimit)
+            : await scheduleStopFailureRetry(input, context, failure);
         if (retryResult === "scheduled") {
             return {
                 ok: true,
@@ -586,6 +598,7 @@ export function createClaudeHookService(deps) {
                 role: input.role,
                 error: options.gatewayStopFailure.error,
                 errorDetails: options.gatewayStopFailure.errorDetails,
+                lastAssistantMessage: options.gatewayStopFailure.lastAssistantMessage,
                 attempt: options.gatewayStopFailure.attempt,
                 maxAttempts: options.gatewayStopFailure.maxAttempts
             }).catch(() => undefined);
@@ -751,6 +764,76 @@ export function createClaudeHookService(deps) {
         scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
         return "scheduled";
     }
+    // Waits for the usage limit to reset instead of retrying on the short-term
+    // schedule, which would give up after about three and a half hours while a
+    // session or weekly limit can last longer. Waits do not count as retry
+    // attempts, and Gateway hears about the limit once, when the wait starts.
+    async function scheduleUsageLimitRetry(input, context, failure, usageLimit) {
+        const preferences = await deps.appSettings.getPreferences();
+        if (!preferences.roleRetryEnabled || !deps.runtime) {
+            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 "manual-interrupt";
+        }
+        const previous = currentRoundState.roleRecovery?.role === input.role
+            && currentRoundState.roleRecovery.status !== "failed"
+            ? currentRoundState.roleRecovery
+            : undefined;
+        const alreadyWaiting = previous?.waitReason === "usage-limit";
+        const timestamp = now();
+        const nowMs = Date.parse(timestamp);
+        const limitSince = alreadyWaiting && previous?.limitSince ? previous.limitSince : timestamp;
+        const usageLimitFailure = { ...failure, usageLimit: { resetAt: usageLimit.resetAt, limitSince } };
+        if (nowMs - Date.parse(limitSince) >= MAX_USAGE_LIMIT_WAIT_MS) {
+            await markStopFailureRecoveryFailed(input, context, usageLimitFailure, previous?.attempt ?? 0, timestamp);
+            return "not-scheduled";
+        }
+        const resetMs = usageLimit.resetAt ? Date.parse(usageLimit.resetAt) : Number.NaN;
+        const nextRetryAt = new Date(resetMs > nowMs
+            ? resetMs + USAGE_LIMIT_RESET_BUFFER_MS
+            : nowMs + USAGE_LIMIT_UNKNOWN_RESET_RETRY_MS).toISOString();
+        const attempt = previous?.attempt ?? 0;
+        await deps.roundService.setRoleRecovery({
+            ...stateInput,
+            recovery: {
+                role: input.role,
+                status: "waiting",
+                attempt,
+                maxAttempts: MAX_ROLE_RETRY_ATTEMPTS,
+                lastFailureAt: timestamp,
+                error: failure.error,
+                errorDetails: failure.errorDetails,
+                lastAssistantMessage: failure.lastAssistantMessage,
+                retryable: true,
+                nextRetryAt,
+                waitReason: "usage-limit",
+                limitResetAt: usageLimit.resetAt,
+                limitSince
+            }
+        });
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
+        if (session) {
+            await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role, session.id);
+        }
+        scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
+        if (!alreadyWaiting && (await isHookSessionBoundToTask(context, input.role))) {
+            void deps.gatewayService?.handleRoleStopFailure({
+                repoRoot: context.project.repoRoot,
+                taskSlug: context.taskSlug,
+                role: input.role,
+                error: failure.error,
+                errorDetails: failure.errorDetails,
+                lastAssistantMessage: failure.lastAssistantMessage,
+                usageLimitWait: { resetAt: usageLimit.resetAt, nextRetryAt }
+            }).catch(() => undefined);
+        }
+        return "scheduled";
+    }
     async function isManualInterruptedStopFailure(context, role) {
         try {
             const state = await deps.roundService.getSessionRoundState(createRoundStateInput(context));
@@ -831,7 +914,10 @@ export function createClaudeHookService(deps) {
                 errorDetails: failure.errorDetails,
                 lastAssistantMessage: failure.lastAssistantMessage,
                 retryable: failure.retryable,
-                failedAt: timestamp
+                failedAt: timestamp,
+                ...(failure.usageLimit
+                    ? { waitReason: "usage-limit", limitResetAt: failure.usageLimit.resetAt, limitSince: failure.usageLimit.limitSince }
+                    : {})
             }
         });
     }

package/dist/backend/services/translation-service.js

@@ -127,7 +127,7 @@ export function createTranslationService(deps) {
         taskFeeds.set(key, created);
         return created;
     }
-    async function prepareCache(input) {
+    async function prepareCache(input, options = {}) {
         const state = getState(input.sessionId);
         state.repoRoot = input.repoRoot;
         state.baseRepoRoot = input.baseRepoRoot ?? input.repoRoot;
@@ -145,7 +145,9 @@ export function createTranslationService(deps) {
             pruneTranslationEntries(input.sessionId);
         }
         syncTaskFeedFromSessionState(input.sessionId, state);
-        await deps.fs.ensureDir(path.dirname(cachePath));
+        if (options.createDir !== false) {
+            await deps.fs.ensureDir(path.dirname(cachePath));
+        }
         return state;
     }
     async function loadCachedEvents(state) {
@@ -1311,13 +1313,16 @@ export function createTranslationService(deps) {
         };
         const roleSession = await getGatewayRoleSession(input);
         if (roleSession) {
+            // A lookup only reads. A stopped session has no transcript tail to write
+            // events, and its task may be closing: creating the cache directory there
+            // would recreate the removed task worktree.
             const state = await prepareCache({
                 repoRoot: roleSession.cwd,
                 baseRepoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
                 role: input.role,
                 sessionId: roleSession.id
-            });
+            }, { createDir: roleSession.status === "running" });
             if (roleSession.status === "running") {
                 startTranscriptTail(roleSession);
             }

package/dist/backend/services/usage-limit.js

@@ -0,0 +1,133 @@
+// Claude Code reports a plan usage limit (the session or weekly limit) as an
+// ordinary `rate_limit` API error, the same type as short-term throttling.
+// Only the rendered message tells them apart, and it carries the reset time:
+//   "You've hit your session limit · resets 5:50pm (Asia/Singapore)"
+// Retrying before that time cannot succeed, so a usage limit waits for the
+// reset instead of following the short-term retry schedule.
+// A reset further away than this is treated as unparsed; weekly limits reset
+// within seven days.
+export const MAX_USAGE_LIMIT_RESET_MS = 8 * 24 * 60 * 60 * 1000;
+const USAGE_LIMIT_ERRORS = new Set(["rate_limit", "unknown"]);
+const USAGE_LIMIT_PATTERNS = [
+    /\bhit your\b[^\n]*?\blimit\b/i,
+    /\busage limit\b/i,
+    /\b(?:session|weekly|daily|monthly)\s+limit\b/i
+];
+const RESET_PATTERN = /\bresets?\s+(?:at\s+|on\s+)?([^()\n]+?)\s*\(([A-Za-z_]+(?:\/[A-Za-z0-9_+-]+)+|UTC|GMT)\)/i;
+const TIME_PATTERN = /(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*$/i;
+const DATE_PATTERN = /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\.?\s+(\d{1,2})\b/i;
+const MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function detectUsageLimit(failure, now) {
+    if (!USAGE_LIMIT_ERRORS.has(failure.error)) {
+        return undefined;
+    }
+    const message = [failure.lastAssistantMessage, failure.errorDetails]
+        .find((text) => Boolean(text) && USAGE_LIMIT_PATTERNS.some((pattern) => pattern.test(text)));
+    if (!message) {
+        return undefined;
+    }
+    return { message, resetAt: parseUsageLimitReset(message, now) };
+}
+// Parses "resets 5:50pm (Asia/Singapore)" or "resets Nov 12, 9am
+// (America/Los_Angeles)" into the next matching instant after `now`.
+export function parseUsageLimitReset(message, now) {
+    const match = RESET_PATTERN.exec(message);
+    if (!match) {
+        return undefined;
+    }
+    const when = match[1].trim();
+    const timeZone = match[2];
+    if (!isTimeZone(timeZone)) {
+        return undefined;
+    }
+    const time = TIME_PATTERN.exec(when);
+    if (!time) {
+        return undefined;
+    }
+    let hour = Number(time[1]);
+    const minute = Number(time[2] ?? 0);
+    const meridiem = time[3]?.toLowerCase();
+    if (minute > 59) {
+        return undefined;
+    }
+    if (meridiem) {
+        if (hour < 1 || hour > 12) {
+            return undefined;
+        }
+        hour = (hour % 12) + (meridiem === "pm" ? 12 : 0);
+    }
+    else if (hour > 23) {
+        return undefined;
+    }
+    const today = zonedDate(now, timeZone);
+    const date = DATE_PATTERN.exec(when);
+    let resetMs;
+    if (date) {
+        const month = MONTHS.indexOf(date[1].toLowerCase().slice(0, 3)) + 1;
+        const day = Number(date[2]);
+        const explicitYear = /\b(20\d{2})\b/.exec(when)?.[1];
+        const year = explicitYear ? Number(explicitYear) : today.year;
+        resetMs = zonedTimeToUtc(year, month, day, hour, minute, timeZone);
+        if (!explicitYear && resetMs < now.getTime() - DAY_MS) {
+            resetMs = zonedTimeToUtc(year + 1, month, day, hour, minute, timeZone);
+        }
+    }
+    else {
+        resetMs = zonedTimeToUtc(today.year, today.month, today.day, hour, minute, timeZone);
+        if (resetMs <= now.getTime()) {
+            resetMs = zonedTimeToUtc(today.year, today.month, today.day + 1, hour, minute, timeZone);
+        }
+    }
+    if (!Number.isFinite(resetMs) || resetMs - now.getTime() > MAX_USAGE_LIMIT_RESET_MS) {
+        return undefined;
+    }
+    return new Date(resetMs).toISOString();
+}
+function isTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function zonedParts(instantMs, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+    }).formatToParts(new Date(instantMs));
+    const value = (type) => Number(parts.find((part) => part.type === type)?.value);
+    return {
+        year: value("year"),
+        month: value("month"),
+        day: value("day"),
+        hour: value("hour"),
+        minute: value("minute"),
+        second: value("second")
+    };
+}
+function zonedDate(now, timeZone) {
+    const parts = zonedParts(now.getTime(), timeZone);
+    return { year: parts.year, month: parts.month, day: parts.day };
+}
+// The time zone's offset from UTC at an instant, in milliseconds.
+function offsetMs(instantMs, timeZone) {
+    const parts = zonedParts(instantMs, timeZone);
+    const asUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    return asUtc - Math.floor(instantMs / 1000) * 1000;
+}
+// The UTC instant of a wall-clock time in a time zone; the second pass
+// corrects for an offset change (daylight saving) between the two guesses.
+function zonedTimeToUtc(year, month, day, hour, minute, timeZone) {
+    const wallClockAsUtc = Date.UTC(year, month - 1, day, hour, minute);
+    const first = wallClockAsUtc - offsetMs(wallClockAsUtc, timeZone);
+    return wallClockAsUtc - offsetMs(first, timeZone);
+}