vibe-coding-master 0.9.8 → 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/server.js

@@ -275,7 +275,8 @@ export function createDefaultServerDeps(options = {}) {
     const workflowControlService = createWorkflowControlService({ fs });
     const artifactService = createArtifactService(fs, {
         workflowControlService,
-        getDurableDocAssignment: (taskRepoRoot, role) => autoMemoryService.getDurableDocAssignment(taskRepoRoot, role)
+        getDurableDocAssignment: (taskRepoRoot, role) => autoMemoryService.getDurableDocAssignment(taskRepoRoot, role),
+        getCompletedDurableDocAssignment: (taskRepoRoot, role, artifactPath) => autoMemoryService.getCompletedDurableDocAssignment(taskRepoRoot, role, artifactPath)
     });
     const projectService = createProjectService({
         fs,

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

@@ -220,6 +220,16 @@ export function createArtifactService(fs, deps = {}) {
                     }
                 }
                 else if (input.artifactPath?.trim()) {
+                    const completed = input.kind === "docs-update-report"
+                        ? await deps.getCompletedDurableDocAssignment?.(input.repoRoot, input.role, input.artifactPath.trim())
+                        : undefined;
+                    if (completed) {
+                        throw new VcmError({
+                            code: "DURABLE_DOC_ASSIGNMENT_COMPLETED",
+                            message: `Durable-documentation assignment ${completed.id} is already completed${completed.commit ? ` (commit ${completed.commit})` : ""}, and VCM accepted its report. No action is needed; end the turn.`,
+                            statusCode: 409
+                        });
+                    }
                     throw artifactRejected(input.kind, ["--path is not allowed for fixed artifact kinds."]);
                 }
                 const artifactPath = assignment?.reportPath ?? path.posix.join(input.handoffDir, definition.fileName ?? "");

package/dist/backend/services/auto-memory-service.js

@@ -18,6 +18,7 @@ const MEMORY_FILE_DEFINITIONS = [
     { path: ".claude/agents/reviewer.md", title: "Reviewer Memory", role: "reviewer" },
     { path: ".claude/agents/harness-engineer.md", title: "Harness Engineer Memory", role: "harness-engineer" }
 ];
+const DURABLE_DOC_TURN_END_GRACE_MS = 30 * 1000;
 export function createAutoMemoryService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const taskLocks = new Map();
@@ -382,6 +383,24 @@ export function createAutoMemoryService(deps) {
         const assignment = state?.status === "documenting" ? currentDurableDocAssignment(state) : undefined;
         return assignment?.status === "running" && assignment.owner === role ? assignment : undefined;
     }
+    async function getCompletedDurableDocAssignment(taskRepoRoot, role, artifactPath) {
+        const runId = artifactPath.startsWith(`${MEMORY_REVIEW_RUNS_ROOT}/`)
+            ? artifactPath.slice(MEMORY_REVIEW_RUNS_ROOT.length + 1).split("/")[0]
+            : undefined;
+        if (!runId) {
+            return undefined;
+        }
+        let run;
+        try {
+            run = await readRun(taskRepoRoot, runId);
+        }
+        catch {
+            return undefined;
+        }
+        return run.assignments?.find((assignment) => assignment.status === "completed"
+            && assignment.owner === role
+            && assignment.reportPath === artifactPath);
+    }
     async function handleRoleHook(input) {
         const state = await loadActiveState(input.taskRepoRoot);
         if (!(await deps.appSettings.getPreferences()).autoMemoryEnabled && !preserveDisabledReview(state)) {
@@ -764,7 +783,12 @@ export function createAutoMemoryService(deps) {
                 return;
             }
             const existing = await deps.sessionService.getRoleSession(baseRepoRoot, state.taskSlug, role);
-            if (existing?.activityStatus === "running" && deps.runtime.getSession(existing.id)) {
+            // The assignment's turn reports its own end through the Stop hook, so a
+            // live session keeps the assignment. Sending it again here would queue a
+            // duplicate prompt behind that turn.
+            if (existing?.status === "running"
+                && deps.runtime.getSession(existing.id)
+                && !turnInterruptedAfterDispatch(existing, assignment)) {
                 return;
             }
             assignment.status = assignment.owner ? "pending" : "waiting-owner";
@@ -803,6 +827,21 @@ export function createAutoMemoryService(deps) {
         await submitTerminalInput(deps.runtime, session.id, assignment.owner
             ? buildDurableDocAssignmentPrompt(taskRepoRoot, assignment)
             : buildDurableDocOwnerPrompt(taskRepoRoot, assignment));
+        // Until the role's UserPromptSubmit hook arrives the session still looks
+        // idle; mark it running so nothing dispatches into it meanwhile.
+        await deps.sessionService.markRoleActivityRunning(baseRepoRoot, state.taskSlug, assignment.owner ?? "project-manager", session.id);
+    }
+    // An interrupted turn sends no Stop hook, so its assignment would otherwise
+    // stay running. A turn that ends normally records its end on the session
+    // just before its Stop hook completes or fails the assignment, so the grace
+    // period keeps a reconcile from racing that hook.
+    function turnInterruptedAfterDispatch(session, assignment) {
+        if (session.activityStatus === "running" || !session.lastTurnEndedAt || !assignment.dispatchedAt) {
+            return false;
+        }
+        const endedAt = Date.parse(session.lastTurnEndedAt);
+        return endedAt > Date.parse(assignment.dispatchedAt)
+            && Date.parse(now()) - endedAt >= DURABLE_DOC_TURN_END_GRACE_MS;
     }
     async function finishDurableDocAssignments(taskRepoRoot, state) {
         const failed = state.assignments.filter((assignment) => assignment.status === "failed");
@@ -1471,6 +1510,7 @@ export function createAutoMemoryService(deps) {
         cancelTaskRetrospectiveReview,
         isRoleMemoryTurn,
         getDurableDocAssignment,
+        getCompletedDurableDocAssignment,
         handleRoleHook: (input) => withTaskLock(input.taskRepoRoot, () => handleRoleHook(input)),
         handleHarnessEngineerHook: (input) => withTaskLock(input.taskRepoRoot, () => handleHarnessEngineerHook(input)),
         assertHarnessEngineerAvailable

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/gate-review-service.js

@@ -38,6 +38,14 @@ const SOURCE_ARTIFACTS = {
         ".ai/vcm/gate-reviews/validation-adequacy-review.md"
     ]
 };
+// Reviewer reads the Debug and Diagnosis handoffs, but they stay out of the
+// validation-adequacy input hash: a Post-Validation Docs Correction rewrites
+// them, and like docs it changes no code or test evidence. Code and test
+// changes still change the tracked-evidence hash.
+const VALIDATION_HASH_EXCLUDED_ARTIFACTS = new Set([
+    ".ai/vcm/handoffs/architect-debug.md",
+    ".ai/vcm/handoffs/architecture-diagnosis.md"
+]);
 const CODE_DIFF_SOURCE_ARTIFACTS = {
     coder: [
         ".ai/vcm/handoffs/architecture-plan.md",
@@ -1279,7 +1287,7 @@ async function computeInputHash(deps, taskRepoRoot, gate, codeDiffInput, codeDif
         ".ai/tools/request-gate-review",
         "docs/CODING_STANDARDS.md"
     ];
-    const sourceArtifacts = getSourceArtifacts(gate, codeDiffSources);
+    const sourceArtifacts = getSourceArtifacts(gate, codeDiffSources).filter((item) => gate !== "validation-adequacy" || !VALIDATION_HASH_EXCLUDED_ARTIFACTS.has(item));
     for (const relativePath of new Set([...common, ...sourceArtifacts].filter((item) => item !== coreArtifact))) {
         digest.update(relativePath);
         const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);

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);
+}