vibe-coding-master 0.4.19 → 0.4.21

package/dist/backend/adapters/git-adapter.js

@@ -201,6 +201,21 @@ export function createGitAdapter(runner) {
                 hint: result.stderr
             });
         },
+        async mergeBranchFastForward(repoRoot, branch) {
+            const result = await runGit(runner, repoRoot, ["merge", "--ff-only", branch]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_MERGE_FAILED",
+                    message: `Unable to fast-forward merge branch: ${branch}`,
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout || "Rebase the task branch onto the connected repository branch, then try again."
+                });
+            }
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        },
         async addPaths(repoRoot, paths) {
             if (paths.length === 0) {
                 return;

package/dist/backend/api/harness-routes.js

@@ -38,6 +38,13 @@ export function registerHarnessRoutes(app, deps) {
             commitSha: request.query.commit
         });
     });
+    app.post("/api/projects/harness/repository-diff/merge-to-current-branch", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.harnessService.mergeRepositoryDiffToCurrentBranch(project.repoRoot, {
+            taskRepoRoot: task.worktreePath,
+            taskBranch: task.branch
+        });
+    });
     app.get("/api/projects/harness/bootstrap", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
         try {
@@ -119,6 +126,16 @@ export function registerHarnessRoutes(app, deps) {
             comment: typeof request.body?.comment === "string" ? request.body.comment : undefined
         });
     });
+    app.post("/api/projects/harness/task-retrospective", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        const trigger = request.body?.trigger === "auto" ? "auto" : "manual";
+        return deps.harnessFeedbackService.startTaskRetrospective(project.repoRoot, {
+            taskSlug: task.taskSlug,
+            taskRepoRoot: task.worktreePath,
+            handoffDir: task.handoffDir,
+            trigger
+        });
+    });
 }
 function degradedHarnessStatus(error) {
     return {

package/dist/backend/api/task-routes.js

@@ -1,4 +1,4 @@
-import { CORE_VCM_ROLE_NAMES, DISPATCHABLE_ROLES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES, VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -41,7 +41,7 @@ export function registerTaskRoutes(app, deps) {
 async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
     const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
     for (const session of sessions) {
-        if (session.status === "running" && CORE_VCM_ROLE_NAMES.some((role) => role === session.role)) {
+        if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
             await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
         }
     }

package/dist/backend/app-version.js

@@ -0,0 +1,12 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+export function readVcmPackageVersion(appRoot) {
+    const packageJsonPath = path.join(appRoot, "package.json");
+    try {
+        const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return typeof raw.version === "string" && raw.version.trim() ? raw.version : "unknown";
+    }
+    catch {
+        return process.env.npm_package_version || "unknown";
+    }
+}

package/dist/backend/cli/install-vcm-harness.js

@@ -18,9 +18,10 @@ import { renderVcmHarnessBootstrapSkillRules } from "../templates/harness/vcm-ha
 import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/vcm-long-running-validation-skill.js";
 import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-report-harness-issue-skill.js";
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
-const HARNESS_VERSION = "0.3.0-fixed";
+import { readVcmPackageVersion } from "../app-version.js";
 const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(CLI_DIR, "../../..");
+const VCM_PACKAGE_VERSION = readVcmPackageVersion(APP_ROOT);
 const MANIFEST_PATH = ".ai/vcm-harness-manifest.json";
 const HTML_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=\d+)? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=\d+)?\n[\s\S]*?# VCM:END/m;
@@ -331,7 +332,7 @@ async function buildManifest(projectRoot) {
     return {
         schemaVersion: 1,
         manager: "vcm",
-        harnessVersion: HARNESS_VERSION,
+        harnessVersion: VCM_PACKAGE_VERSION,
         installMode: "fixed",
         installedAt: typeof current?.installedAt === "string" ? current.installedAt : now,
         updatedAt: now,

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

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { CORE_VCM_ROLE_DEFINITIONS, CORE_VCM_ROLE_NAMES, GATE_REVIEWER_ROLE_DEFINITION } from "../../shared/constants.js";
+import { CORE_VCM_ROLE_DEFINITIONS, GATE_REVIEWER_ROLE_DEFINITION, VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
@@ -425,9 +425,6 @@ export function createGatewayService(deps) {
                 };
                 const existing = await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, definition.name);
                 if (existing?.status === "running") {
-                    if (definition.name === "gate-reviewer") {
-                        await deps.sessionService.resumeRoleSession(project.repoRoot, task.taskSlug, definition.name, sessionInput);
-                    }
                     startedRoles.push(definition.name);
                     continue;
                 }
@@ -556,7 +553,7 @@ export function createGatewayService(deps) {
     async function stopRunningRoleSessions(repoRoot, taskSlug) {
         const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
         for (const session of sessions) {
-            if (session.status === "running" && CORE_VCM_ROLE_NAMES.some((role) => role === session.role)) {
+            if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
                 await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
             }
         }

package/dist/backend/server.js

@@ -46,6 +46,7 @@ import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
 import { registerTerminalWs } from "./ws/terminal-ws.js";
 import { toVcmError } from "./errors.js";
+import { readVcmPackageVersion } from "./app-version.js";
 export async function createServer(deps, options = {}) {
     const app = Fastify({
         logger: false
@@ -161,6 +162,8 @@ export async function startServer(options = {}) {
 }
 export function createDefaultServerDeps(options = {}) {
     const fs = createNodeFileSystemAdapter();
+    const appRoot = getAppRoot();
+    const vcmVersion = readVcmPackageVersion(appRoot);
     const runner = createCommandRunner();
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
@@ -185,7 +188,8 @@ export function createDefaultServerDeps(options = {}) {
         git,
         runtime,
         harnessEngineerSessions: sessionService,
-        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(getAppRoot(), "scripts/install-vcm-harness.mjs"))
+        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(appRoot, "scripts/install-vcm-harness.mjs")),
+        vcmVersion
     });
     const harnessFeedbackService = createHarnessFeedbackService({
         fs,
@@ -277,7 +281,7 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService
     });
     const diagnosticsService = createDiagnosticsService({
-        appRoot: getAppRoot(),
+        appRoot,
         runtime,
         gatewayService,
         translationService

package/dist/backend/services/app-settings-service.js

@@ -230,7 +230,9 @@ function normalizePreferences(input) {
     return {
         themeMode: normalizeThemeMode(candidate.themeMode),
         flowPauseAlerts: rawFlowPauseAlerts !== false,
+        roleRetryEnabled: candidate.roleRetryEnabled !== false,
         permissionRequestMode: normalizePermissionRequestMode(candidate.permissionRequestMode),
+        autoTaskHarnessReviewEnabled: candidate.autoTaskHarnessReviewEnabled === true,
         translationEnabled: candidate.translationEnabled === true,
         translationAutoSendEnabled: candidate.translationAutoSendEnabled === true,
         translationTargetLanguage: normalizeTranslationTargetLanguage(candidate.translationTargetLanguage),

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

@@ -2,9 +2,22 @@ import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorTool
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
-const MAX_STOP_FAILURE_RECOVERY_ATTEMPTS = 2;
+const MAX_ROLE_RETRY_ATTEMPTS = 20;
+const ROLE_RETRY_BASE_DELAY_MS = 60_000;
+const NON_RETRYABLE_STOP_FAILURE_ERRORS = new Set([
+    "authentication_failed",
+    "oauth_org_not_allowed",
+    "billing_error",
+    "invalid_request",
+    "model_not_found",
+    "max_output_tokens"
+]);
+const DIAGNOSTIC_SNIPPET_MAX_LENGTH = 2000;
 export function createClaudeHookService(deps) {
-    const stopFailureRecoveryAttempts = new Map();
+    const stopFailureRetryTimers = new Map();
+    const now = deps.now ?? (() => new Date().toISOString());
+    const retrySetTimeout = deps.retrySetTimeout ?? ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
+    const retryClearTimeout = deps.retryClearTimeout ?? ((timer) => globalThis.clearTimeout(timer));
     async function getHookContext(input) {
         if (!isVcmRoleName(input.role)) {
             throw new VcmError({
@@ -99,19 +112,8 @@ export function createClaudeHookService(deps) {
         };
     }
     async function resolveHookTaskSlug(repoRoot, input) {
-        if (!isGateReviewerRoleName(input.role)) {
-            return input.taskSlug;
-        }
-        const session = await deps.sessionService.getProjectGateReviewerSession(repoRoot);
-        if (session?.activeTaskSlug) {
-            return session.activeTaskSlug;
-        }
-        throw new VcmError({
-            code: "GATE_REVIEWER_TASK_UNBOUND",
-            message: "Gate Reviewer hook arrived without an active task binding.",
-            statusCode: 409,
-            hint: "Start or resume Gate Reviewer from the current task before submitting work."
-        });
+        void repoRoot;
+        return input.taskSlug;
     }
     async function handleUserPromptSubmitHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
@@ -177,7 +179,7 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
-        clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, input.role);
+        await clearStopFailureRecoveryState(context, input.role);
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
                 repoRoot: context.project.repoRoot,
@@ -215,15 +217,24 @@ export function createClaudeHookService(deps) {
         const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
         const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
         if (hasCompletionEvidence) {
-            clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, input.role);
+            await clearStopFailureRecoveryState(context, input.role);
             return recordTurnEnd(input, context, eventName, {
                 dispatchRouteFiles: !isGateReviewerRoleName(input.role),
                 notifyGateway: false,
                 settleGuard: true
             });
         }
-        const recovered = await dispatchStopFailureRecovery(input, context);
-        if (recovered) {
+        const failure = parseStopFailureDiagnostic(input.event);
+        if (!failure.retryable) {
+            await markStopFailureRecoveryFailed(input, context, failure, 0);
+            return recordTurnEnd(input, context, eventName, {
+                dispatchRouteFiles: false,
+                notifyGateway: false,
+                settleGuard: false
+            });
+        }
+        const retryScheduled = await scheduleStopFailureRetry(input, context, failure);
+        if (retryScheduled) {
             return {
                 ok: true,
                 eventName,
@@ -336,38 +347,147 @@ export function createClaudeHookService(deps) {
             ...(stoppedRole ? { stoppedRole } : {})
         };
     }
-    async function dispatchStopFailureRecovery(input, context) {
-        if (!deps.runtime) {
+    async function scheduleStopFailureRetry(input, context, failure) {
+        const preferences = await deps.appSettings.getPreferences();
+        if (!preferences.roleRetryEnabled || !deps.runtime) {
             return false;
         }
-        const key = stopFailureRecoveryKey(context.project.repoRoot, context.taskSlug, input.role);
-        const attempt = (stopFailureRecoveryAttempts.get(key) ?? 0) + 1;
-        if (attempt > MAX_STOP_FAILURE_RECOVERY_ATTEMPTS) {
+        const stateInput = createRoundStateInput(context);
+        const currentRoundState = await deps.roundService.getSessionRoundState(stateInput);
+        const previousAttempt = currentRoundState.roleRecovery?.role === input.role &&
+            currentRoundState.roleRecovery.status !== "failed"
+            ? currentRoundState.roleRecovery.attempt
+            : 0;
+        const attempt = previousAttempt + 1;
+        const timestamp = now();
+        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;
         }
+        const nextRetryAt = new Date(Date.parse(timestamp) + attempt * ROLE_RETRY_BASE_DELAY_MS).toISOString();
+        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: failure.retryable,
+                nextRetryAt
+            }
+        });
+        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
+        scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
+        return true;
+    }
+    function scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt) {
+        const key = stopFailureRecoveryKey(context.project.repoRoot, context.taskSlug, input.role);
+        clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
+        const delayMs = Math.max(0, Date.parse(nextRetryAt) - Date.parse(now()));
+        const timer = retrySetTimeout(() => {
+            stopFailureRetryTimers.delete(key);
+            void runScheduledStopFailureRetry(input, context, attempt).catch(() => undefined);
+        }, delayMs);
+        stopFailureRetryTimers.set(key, timer);
+    }
+    async function runScheduledStopFailureRetry(input, context, attempt) {
+        const stateInput = createRoundStateInput(context);
+        const currentRoundState = await deps.roundService.getSessionRoundState(stateInput);
+        const recovery = currentRoundState.roleRecovery;
+        if (!recovery || recovery.role !== input.role || recovery.attempt !== attempt || recovery.status !== "waiting") {
+            return;
+        }
+        const timestamp = now();
         const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
-        if (!session || session.status !== "running") {
-            return false;
+        if (!session || session.status !== "running" || !deps.runtime) {
+            await deps.roundService.setRoleRecovery({
+                ...stateInput,
+                recovery: {
+                    ...recovery,
+                    status: "failed",
+                    failedAt: timestamp
+                }
+            });
+            await recordTurnEnd(input, context, "StopFailure", {
+                dispatchRouteFiles: false,
+                notifyGateway: false,
+                settleGuard: false
+            });
+            return;
         }
-        stopFailureRecoveryAttempts.set(key, attempt);
-        await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt(attempt));
+        await deps.roundService.setRoleRecovery({
+            ...stateInput,
+            recovery: {
+                ...recovery,
+                status: "retrying",
+                nextRetryAt: undefined,
+                lastRetryAt: timestamp
+            }
+        });
+        await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt());
         await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
-        return true;
+    }
+    async function markStopFailureRecoveryFailed(input, context, failure, attempt, timestamp = now()) {
+        clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
+        await deps.roundService.setRoleRecovery({
+            ...createRoundStateInput(context),
+            recovery: {
+                role: input.role,
+                status: "failed",
+                attempt,
+                maxAttempts: MAX_ROLE_RETRY_ATTEMPTS,
+                lastFailureAt: timestamp,
+                error: failure.error,
+                errorDetails: failure.errorDetails,
+                lastAssistantMessage: failure.lastAssistantMessage,
+                retryable: failure.retryable,
+                failedAt: timestamp
+            }
+        });
     }
     function clearStopFailureRecovery(repoRoot, taskSlug, role) {
-        stopFailureRecoveryAttempts.delete(stopFailureRecoveryKey(repoRoot, taskSlug, role));
+        clearStopFailureRetryTimer(repoRoot, taskSlug, role);
+    }
+    async function clearStopFailureRecoveryState(context, role) {
+        clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, role);
+        await deps.roundService.clearRoleRecovery?.({
+            ...createRoundStateInput(context),
+            role
+        });
+    }
+    function clearStopFailureRetryTimer(repoRoot, taskSlug, role) {
+        const key = stopFailureRecoveryKey(repoRoot, taskSlug, role);
+        const timer = stopFailureRetryTimers.get(key);
+        if (timer === undefined) {
+            return;
+        }
+        retryClearTimeout(timer);
+        stopFailureRetryTimers.delete(key);
     }
     function stopFailureRecoveryKey(repoRoot, taskSlug, role) {
         return `${repoRoot}:${taskSlug}:${role}`;
     }
-    function renderStopFailureRecoveryPrompt(attempt) {
+    function createRoundStateInput(context) {
+        return {
+            repoRoot: context.project.repoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            taskSlug: context.taskSlug
+        };
+    }
+    function renderStopFailureRecoveryPrompt() {
         return [
             "[VCM Recovery]",
-            "Your previous turn ended unexpectedly after context compaction or an API error.",
-            "Continue the same assigned work from the current repository and VCM handoff state.",
-            "Do not repeat completed edits, duplicate validation, or duplicate route messages.",
-            "If the assigned work is already complete, write/send the expected VCM handoff now.",
-            `Recovery attempt: ${attempt}/${MAX_STOP_FAILURE_RECOVERY_ATTEMPTS}.`
+            "Previous turn ended unexpectedly. Continue from current repo + VCM handoff state.",
+            "",
+            "Check whether your assigned work is already complete.",
+            "If complete, write the expected VCM completion artifact now.",
+            "Do not repeat completed edits, validation, or route messages."
         ].join("\n");
     }
     async function handlePermissionRequestHook(input) {
@@ -470,6 +590,38 @@ function throwUnsupportedEvent(eventName) {
         hint: "Use the matching VCM hook endpoint for this event."
     });
 }
+function parseStopFailureDiagnostic(event) {
+    const error = (normalizeDiagnosticString(event.error, 200) ?? "unknown").toLowerCase();
+    const errorDetails = normalizeDiagnosticString(event.error_details, DIAGNOSTIC_SNIPPET_MAX_LENGTH);
+    const lastAssistantMessage = normalizeDiagnosticString(event.last_assistant_message, DIAGNOSTIC_SNIPPET_MAX_LENGTH);
+    return {
+        error,
+        errorDetails,
+        lastAssistantMessage,
+        retryable: !NON_RETRYABLE_STOP_FAILURE_ERRORS.has(error)
+    };
+}
+function normalizeDiagnosticString(value, maxLength) {
+    let text;
+    if (typeof value === "string") {
+        text = value;
+    }
+    else if (value !== undefined && value !== null) {
+        try {
+            text = JSON.stringify(value);
+        }
+        catch {
+            text = String(value);
+        }
+    }
+    const trimmed = text?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.length > maxLength
+        ? `${trimmed.slice(0, maxLength)}...`
+        : trimmed;
+}
 function stringOrUndefined(value) {
     return typeof value === "string" ? value : undefined;
 }

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

@@ -1,8 +1,7 @@
-import { readFileSync } from "node:fs";
 import fs from "node:fs/promises";
-import path from "node:path";
+import { readVcmPackageVersion } from "../app-version.js";
 export function createDiagnosticsService(deps) {
-    const version = readPackageVersion(deps.appRoot);
+    const version = readVcmPackageVersion(deps.appRoot);
     return {
         async getRuntimeDiagnostics() {
             const runtimeSessions = deps.runtime.listSessions();
@@ -34,16 +33,6 @@ export function createDiagnosticsService(deps) {
         }
     };
 }
-function readPackageVersion(appRoot) {
-    const packageJsonPath = path.join(appRoot, "package.json");
-    try {
-        const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-        return typeof raw.version === "string" && raw.version.trim() ? raw.version : "unknown";
-    }
-    catch {
-        return process.env.npm_package_version || "unknown";
-    }
-}
 async function readFdCount() {
     try {
         return (await fs.readdir("/proc/self/fd")).length;