vibe-coding-master 0.4.17 → 0.4.19

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

@@ -29,6 +29,18 @@ export function registerTranslationRoutes(app, deps) {
             ...(request.body ?? { text: "" })
         });
     });
+    app.post("/api/tasks/:taskSlug/sessions/:role/translation/manual-output", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.translationService.translateManualOutput({
+            repoRoot: project.repoRoot,
+            taskRepoRoot: getTaskRuntimeRepoRoot(task),
+            taskSlug: request.params.taskSlug,
+            role,
+            text: request.body?.text ?? ""
+        });
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/translation/send", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);

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

@@ -592,7 +592,6 @@ export function createGatewayService(deps) {
         }
         const enabled = await syncDesktopContext(await deps.settings.updateSettings({ enabled: true }));
         await ensurePolling();
-        await deps.appSettings.updatePreferences({ flowPauseAlerts: false });
         const lines = [
             "Gateway started.",
             "Full mobile commands and PM messages are now enabled.",

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

@@ -18,6 +18,16 @@ export function createTaskService(deps) {
                     statusCode: 409
                 });
             }
+            const existingTasks = await readStoredTasks(deps.fs, taskStoreRoot);
+            const activeTask = existingTasks.find((task) => task.cleanupStatus !== "cleaned");
+            if (activeTask) {
+                throw new VcmError({
+                    code: "ACTIVE_TASK_EXISTS",
+                    message: `A task is already active for this project: ${activeTask.taskSlug}`,
+                    statusCode: 409,
+                    hint: "Close the current task before creating a new one."
+                });
+            }
             if (await deps.git.branchExists(repoRoot, taskBranch)) {
                 throw new VcmError({
                     code: "TASK_BRANCH_EXISTS",
@@ -81,16 +91,7 @@ export function createTaskService(deps) {
             return task;
         },
         async listTasks(repoRoot) {
-            const tasksDir = path.join(deps.projectService.getProjectDataRoot(repoRoot), "tasks");
-            if (!(await deps.fs.pathExists(tasksDir))) {
-                return [];
-            }
-            const entries = await deps.fs.readDir(tasksDir);
-            const tasks = [];
-            for (const entry of entries.filter((candidate) => candidate.endsWith(".json"))) {
-                tasks.push(await deps.fs.readJson(path.join(tasksDir, entry)));
-            }
-            return tasks.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+            return readStoredTasks(deps.fs, deps.projectService.getProjectDataRoot(repoRoot));
         },
         async loadTask(repoRoot, taskSlug) {
             assertValidTaskSlug(taskSlug);
@@ -149,6 +150,18 @@ export function createTaskService(deps) {
         }
     };
 }
+async function readStoredTasks(fs, taskStoreRoot) {
+    const tasksDir = path.join(taskStoreRoot, "tasks");
+    if (!(await fs.pathExists(tasksDir))) {
+        return [];
+    }
+    const entries = await fs.readDir(tasksDir);
+    const tasks = [];
+    for (const entry of entries.filter((candidate) => candidate.endsWith(".json"))) {
+        tasks.push(await fs.readJson(path.join(tasksDir, entry)));
+    }
+    return tasks.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
 export function getTaskRuntimeRepoRoot(task) {
     return task.worktreePath;
 }

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

@@ -165,7 +165,7 @@ export function createTranslationService(deps) {
         const replaySince = getTranscriptReplaySince(roleSession);
         state.unsubscribeTranscript = deps.transcripts.subscribeToRoleSession(roleSession, (event) => {
             void handleTranscriptEvent(roleSession.id, event).catch((error) => {
-                publishError(roleSession.id, error instanceof Error ? error.message : "Translation failed.");
+                publishError(roleSession.id, normalizeTranslationError(error, "Process Claude transcript event for translation failed."));
             });
         }, {
             onError(error) {
@@ -277,13 +277,13 @@ export function createTranslationService(deps) {
         }
         if (delayMs <= 0) {
             void flushClaudeOutputTranslations(sessionId).catch((error) => {
-                publishError(sessionId, error instanceof Error ? error.message : "Translation failed.");
+                publishError(sessionId, normalizeTranslationError(error, "Flush batched Claude output translations failed."));
             });
             return;
         }
         state.outputBatch.timer = setTimeout(() => {
             void flushClaudeOutputTranslations(sessionId).catch((error) => {
-                publishError(sessionId, error instanceof Error ? error.message : "Translation failed.");
+                publishError(sessionId, normalizeTranslationError(error, "Flush delayed Claude output translations failed."));
             });
         }, delayMs);
     }
@@ -355,14 +355,14 @@ export function createTranslationService(deps) {
             }
             publishStatus(sessionId, hasFailure ? "failed" : "ready");
         }).catch((error) => {
-            publishError(sessionId, error instanceof Error ? error.message : "Translation failed.");
+            publishError(sessionId, normalizeTranslationError(error, "Run queued Claude output translation failed."));
         });
     }
     function markOutputTranslationFailed(sessionId, entry, error) {
         const failed = {
             ...entry,
             status: "failed",
-            error: error instanceof Error ? error.message : "Translation failed.",
+            error: normalizeTranslationError(error, "Claude output translation failed."),
             completedAt: now()
         };
         replaceEntry(sessionId, failed);
@@ -428,7 +428,7 @@ export function createTranslationService(deps) {
             taskSlug: entry.taskSlug,
             role: entry.role,
             sourceText: entry.sourceText,
-            error: entry.error ?? "Translation failed.",
+            error: entry.error ?? "Translation failure reason was not recorded.",
             failedAt: entry.completedAt ?? now(),
             retryCount: existing?.retryCount ?? 0,
             lastRetryAt: existing?.lastRetryAt
@@ -488,7 +488,7 @@ export function createTranslationService(deps) {
             taskSlug: original.taskSlug,
             role: original.role,
             sourceText: original.sourceText,
-            error: original.error ?? "Translation failed.",
+            error: original.error ?? "Translation failure reason was not recorded.",
             failedAt: original.completedAt ?? now(),
             retryCount: 0
         };
@@ -707,7 +707,7 @@ export function createTranslationService(deps) {
                 const failed = {
                     ...entry,
                     status: "failed",
-                    error: normalizeTranslationError(error),
+                    error: normalizeTranslationError(error, "Composer input translation failed."),
                     completedAt: now()
                 };
                 if (roleSession) {
@@ -715,11 +715,50 @@ export function createTranslationService(deps) {
                 }
                 throw new VcmError({
                     code: "TRANSLATION_FAILED",
-                    message: failed.error ?? "Translation failed.",
+                    message: failed.error ?? "Composer input translation failed.",
                     statusCode: 502
                 });
             }
         },
+        async translateManualOutput(input) {
+            const config = await loadConfig();
+            if (!input.text.trim()) {
+                throw new VcmError({
+                    code: "TRANSLATION_INPUT_EMPTY",
+                    message: "Manual translation input cannot be empty.",
+                    statusCode: 400
+                });
+            }
+            const roleSession = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+            if (!roleSession || roleSession.status !== "running") {
+                throw new VcmError({
+                    code: "SESSION_NOT_RUNNING",
+                    message: `${input.role} session is not running.`,
+                    statusCode: 409
+                });
+            }
+            await prepareCache({
+                repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                baseRepoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionId: roleSession.id
+            });
+            startTranscriptTail(roleSession);
+            const entry = startClaudeOutputTranslation(roleSession.id, input.text, config, {
+                replaceExisting: false,
+                flushImmediately: true
+            });
+            if (!entry) {
+                throw new VcmError({
+                    code: "TRANSLATION_NOT_STARTED",
+                    message: "Manual translation could not be queued.",
+                    statusCode: 409,
+                    hint: "Check that the role session is still running and try again."
+                });
+            }
+            return entry;
+        },
         async sendTranslatedInput(input) {
             await writeToCurrentRole(input.repoRoot, input.taskSlug, input.role, input.englishText);
         },
@@ -1098,6 +1137,20 @@ function upsertEntry(entries, entry) {
 function getTranslationCachePath(repoRoot, stateRoot, taskSlug, role, sessionId) {
     return path.join(repoRoot, stateRoot, "translation", taskSlug, role, `${sessionId}.jsonl`);
 }
-function normalizeTranslationError(error) {
-    return error instanceof Error ? error.message : "Translation failed.";
+function normalizeTranslationError(error, fallback = "Translation failed before VCM could identify the failing stage.") {
+    if (error instanceof Error) {
+        return error.message || fallback;
+    }
+    if (typeof error === "string" && error.trim()) {
+        return `${fallback} Reason: ${error}`;
+    }
+    if (error === undefined) {
+        return fallback;
+    }
+    try {
+        return `${fallback} Non-Error value: ${JSON.stringify(error)}`;
+    }
+    catch {
+        return `${fallback} Non-Error value: ${String(error)}`;
+    }
 }

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

@@ -226,7 +226,7 @@ export function createTranslationWorkerService(deps) {
             const failedAt = now();
             for (const item of failedItems) {
                 item.status = "failed";
-                item.error = error instanceof Error ? error.message : "Failed to dispatch Translator task.";
+                item.error = describeWorkerError(error, "Dispatch Translator task failed.");
                 item.updatedAt = failedAt;
             }
             queue.activeItemId = undefined;
@@ -437,7 +437,7 @@ export function createTranslationWorkerService(deps) {
         }
         catch (error) {
             active.status = "failed";
-            active.error = error instanceof Error ? error.message : "Failed to finalize translation output.";
+            active.error = describeWorkerError(error, "Finalize translation output failed.");
             active.updatedAt = now();
             queue.updatedAt = active.updatedAt;
             await saveQueue(repoRoot, queue);
@@ -1847,3 +1847,20 @@ function invalidResult(message) {
         statusCode: 422
     });
 }
+function describeWorkerError(error, fallback) {
+    if (error instanceof Error) {
+        return error.message || fallback;
+    }
+    if (typeof error === "string" && error.trim()) {
+        return `${fallback} Reason: ${error}`;
+    }
+    if (error === undefined) {
+        return fallback;
+    }
+    try {
+        return `${fallback} Non-Error value: ${JSON.stringify(error)}`;
+    }
+    catch {
+        return `${fallback} Non-Error value: ${String(error)}`;
+    }
+}

package/dist/backend/templates/harness/gate-review.js

@@ -10,11 +10,49 @@ Return only:
 - \`approve\`: no gate-blocking finding.
 - \`request_changes\`: evidence is missing, stale, contradictory, incomplete, or unsafe.
 
-## Checks
-
-- \`architecture-plan\`: scope, affected files/contracts, Scaffold Manifest, dependencies, docs/generated context, proof points, Replan triggers, no task-only source comments.
-- \`validation-adequacy\`: review report covers the plan, public contracts, validation level, commands/results, skips/gaps/risks, final cleanup, durable testing docs impact.
-- \`final-diff\`: diff matches plan, no unapproved surface/dependency/docs, no \`VCM:CODE\`, no task-process comments, meaningful tests, fallible paths handled.
+## Architecture Plan Gate
+
+Read \`.claude/agents/architect.md\`; use coder/reviewer definitions only when
+judging implementation or validation boundaries. Verify the required plan
+structure, evidence, Scaffold Manifest, proof points, Replan triggers, and no
+task-only source comments.
+
+Focus on architectural soundness. Request changes when module boundaries,
+public surface impact, dependency direction, state ownership, lifecycle,
+failure paths, concurrency/restart behavior, docs/generated-context impact, or
+key design decisions are missing, contradictory, unsafe, left for coder to
+guess, or conflict with current project architecture.
+
+## Validation Adequacy Gate
+
+Read \`.claude/agents/reviewer.md\`; use architect/coder definitions to compare
+validation against the plan and implementation test responsibilities. Verify
+plan coverage, public contracts, validation level, commands/results,
+skips/gaps/risks, final cleanup, and durable testing docs impact.
+
+Focus on whether validation matches risk. Request changes when important user
+or system paths lack integration or E2E case coverage, or when the review
+report does not explain why such coverage is unnecessary or unavailable. Pay
+special attention to module boundaries, public contracts, UI flows,
+CLI/tooling, hooks, sessions, persistence, worktrees, and external process
+behavior.
+
+## Final Diff Gate
+
+Read \`.claude/agents/coder.md\`; use architect/reviewer definitions to compare
+the final diff against the approved plan and validation evidence. Check that
+the diff matches plan, has no unapproved surface/dependency/docs changes, no
+\`VCM:CODE\`, no task-process comments, meaningful tests, and fallible paths
+handled.
+
+Focus on code quality and boundary-condition robustness. Request changes when
+the code violates project style, duplicates existing patterns unnecessarily,
+adds avoidable abstraction, leaves debug/task-only artifacts, handles errors
+inconsistently, changes files outside scope, weakens tests, or misses important
+boundary conditions: empty/missing inputs, invalid data, permissions, external
+command failure, partial writes, retries, concurrency, repeated UI actions,
+stale state, restart recovery, cleanup, compatibility, or public API
+validation.
 
 ## Output
 
@@ -29,7 +67,7 @@ Summary: <one or two sentences>
 
 Findings must include severity, title, evidence, expected, gap, and risk.
 
-Do not edit code, tests, durable docs, role files, route files, or handoff artifacts. Do not choose owners, fixes, Replan, or user-intervention needs.`;
+Do not run tests. Review only code, architecture, and documents; do not perform validation. Do not edit code, tests, durable docs, role files, route files, or handoff artifacts. Do not choose owners, fixes, Replan, or user-intervention needs.`;
 }
 export function renderTranslatorAgentRules() {
     return `## Role