vibe-coding-master 0.4.42 → 0.5.0

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

@@ -83,6 +83,13 @@ export function registerTaskRoutes(app, deps) {
             throw error;
         }
     });
+    app.post("/api/tasks/:taskSlug/one-click-start", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.taskLaunchService.startTaskRoleSessions(project.repoRoot, {
+            taskSlug: request.params.taskSlug,
+            requireFreshStart: true
+        });
+    });
     app.post("/api/tasks/:taskSlug/cleanup", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);

package/dist/backend/errors.js

@@ -2,12 +2,14 @@ export class VcmError extends Error {
     code;
     statusCode;
     hint;
+    details;
     constructor(input) {
         super(input.message);
         this.name = "VcmError";
         this.code = input.code;
         this.statusCode = input.statusCode ?? 400;
         this.hint = input.hint;
+        this.details = input.details;
     }
 }
 export function toVcmError(error) {

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

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { CORE_VCM_ROLE_DEFINITIONS, GATE_REVIEWER_ROLE_DEFINITION, VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { 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";
@@ -430,78 +430,48 @@ export function createGatewayService(deps) {
             taskSlug,
             title
         });
-        const config = await deps.projectService.loadConfig(project.repoRoot);
-        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const preferences = await deps.appSettings.getPreferences();
-        const template = preferences.launchTemplate;
-        await deps.messageService.updateOrchestrationState({
-            repoRoot: project.repoRoot,
-            stateRepoRoot: taskRepoRoot,
-            stateRoot: config.stateRoot,
-            taskSlug: task.taskSlug,
-            mode: template.autoOrchestration ? "auto" : "manual"
-        });
-        const gateReviewSettings = await deps.appSettings.getGateReviewSettings(project.repoRoot, task.taskSlug);
-        const roleDefinitions = [
-            ...CORE_VCM_ROLE_DEFINITIONS,
-            ...(gateReviewSettings.enabled ? [GATE_REVIEWER_ROLE_DEFINITION] : [])
-        ];
-        const startedRoles = [];
-        for (const definition of roleDefinitions) {
-            const roleTemplate = template.roles[definition.name];
-            try {
-                const sessionInput = {
-                    cols: 100,
-                    rows: 28,
-                    permissionMode: roleTemplate.permissionMode,
-                    model: roleTemplate.model,
-                    effort: roleTemplate.effort
-                };
-                const existing = await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, definition.name);
-                if (existing?.status === "running") {
-                    startedRoles.push(definition.name);
-                    continue;
-                }
-                if (existing?.claudeSessionId) {
-                    await deps.sessionService.resumeRoleSession(project.repoRoot, task.taskSlug, definition.name, sessionInput);
-                }
-                else {
-                    await deps.sessionService.startRoleSession(project.repoRoot, task.taskSlug, definition.name, sessionInput);
-                }
-                startedRoles.push(definition.name);
-            }
-            catch (error) {
-                const settings = await deps.settings.loadSettings();
-                await deps.settings.saveSettings({
-                    ...settings,
-                    currentProjectId: project.repoRoot,
-                    currentTaskSlug: task.taskSlug,
-                    translationEnabled: preferences.translationEnabled,
-                    updatedAt: now()
-                });
+        // Persist the gateway's current project/task selection. Done after a partial
+        // start (so the phone stays pointed at the new task) and on success.
+        const persistTaskSelection = async () => {
+            const settings = await deps.settings.loadSettings();
+            await deps.settings.saveSettings({
+                ...settings,
+                currentProjectId: project.repoRoot,
+                currentTaskSlug: task.taskSlug,
+                translationEnabled: preferences.translationEnabled,
+                updatedAt: now()
+            });
+        };
+        // Reuse the shared backend launch orchestration (roster + mode + skip/resume/
+        // start). A freshly created task has no sessions, so requireFreshStart is false.
+        let launch;
+        try {
+            launch = await deps.taskLaunchService.startTaskRoleSessions(project.repoRoot, {
+                taskSlug: task.taskSlug,
+                requireFreshStart: false
+            });
+        }
+        catch (error) {
+            if (error instanceof VcmError && error.code === "TASK_ONE_CLICK_PARTIAL_START") {
+                await persistTaskSelection();
                 throw new VcmError({
                     code: "GATEWAY_TASK_PARTIAL_START",
-                    message: `Task was created, but ${definition.name} failed to start.`,
+                    message: `Task was created, but ${error.message}`,
                     statusCode: 409,
-                    hint: errorMessage(error)
+                    hint: error.hint
                 });
             }
+            throw error;
         }
-        const settings = await deps.settings.loadSettings();
-        await deps.settings.saveSettings({
-            ...settings,
-            currentProjectId: project.repoRoot,
-            currentTaskSlug: task.taskSlug,
-            translationEnabled: preferences.translationEnabled,
-            updatedAt: now()
-        });
+        await persistTaskSelection();
         return [
             `Task created and initialized: ${task.taskSlug}`,
             `branch: ${task.branch}`,
             `worktree: ${task.worktreePath}`,
-            `orchestration: ${template.autoOrchestration ? "auto" : "manual"}`,
+            `orchestration: ${launch.orchestration.mode}`,
             `translation: ${preferences.translationEnabled ? "on" : "off"}`,
-            `sessions: ${startedRoles.join(", ")}`
+            `sessions: ${launch.startedRoles.join(", ")}`
         ].join("\n");
     }
     async function closeTaskPrompt() {

package/dist/backend/server.js

@@ -33,6 +33,7 @@ import { createRoundService } from "./services/round-service.js";
 import { createRuntimeCoordinatorService } from "./services/runtime-coordinator-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
+import { createTaskLaunchService } from "./services/task-launch-service.js";
 import { createTranslationService } from "./services/translation-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
@@ -109,6 +110,7 @@ export async function createServer(deps, options = {}) {
         sessionService: deps.sessionService,
         statusService: deps.statusService,
         messageService: deps.messageService,
+        taskLaunchService: deps.taskLaunchService,
         translationService: deps.translationService,
         roundService: deps.roundService
     });
@@ -232,6 +234,13 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
+    const taskLaunchService = createTaskLaunchService({
+        projectService,
+        taskService,
+        appSettings,
+        sessionService,
+        messageService
+    });
     const roundService = createRoundService({
         fs,
         sessionService,
@@ -286,7 +295,7 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         sessionService,
-        messageService,
+        taskLaunchService,
         translationService,
         roundService,
         runtime,
@@ -337,6 +346,7 @@ export function createDefaultServerDeps(options = {}) {
         commandDispatcher,
         claudeHookService,
         messageService,
+        taskLaunchService,
         gateReviewService,
         translationWorkerService,
         roundService,

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

@@ -383,6 +383,7 @@ function toSessionRoundState(state, updatedAt) {
             totalCcActiveMs: state.totalCcActiveMs,
             currentRoundCcActiveMs: 0,
             roleRecovery: state.roleRecovery,
+            flowPause: computeFlowPause(undefined, state.roleRecovery),
             roles: [],
             updatedAt
         };
@@ -411,10 +412,43 @@ function toSessionRoundState(state, updatedAt) {
         totalCcActiveMs: state.totalCcActiveMs + activeDurationMs,
         currentRoundCcActiveMs,
         roleRecovery: state.roleRecovery,
+        flowPause: computeFlowPause(current, state.roleRecovery),
         roles: current.roles,
         updatedAt
     };
 }
+/**
+ * Authoritative flow-pause predicate (single source of truth). Returns a paused
+ * VcmFlowPauseState exactly when a real round has ended and the auto flow has not
+ * advanced and we are not mid active-recovery — mirroring the decision the GUI
+ * previously derived. Reason is `role-recovery-failed` when recovery has failed,
+ * otherwise `stopped-no-next-turn`. Returns a non-paused state (or undefined) when
+ * the flow is not paused. The frontend consumes this instead of re-deriving it.
+ *
+ * Intended logic (to implement):
+ *   const recovering = roleRecovery?.status === "waiting" || roleRecovery?.status === "retrying";
+ *   const paused = !!current && current.status === "stopped" && !!current.id && !recovering;
+ *   if (!paused) return undefined; // or { paused: false }
+ *   return {
+ *     paused: true,
+ *     reason: roleRecovery?.status === "failed" ? "role-recovery-failed" : "stopped-no-next-turn",
+ *     role: current.activeRole,
+ *     since: current.stoppedAt ?? current.lastTurnEndedAt
+ *   };
+ */
+function computeFlowPause(current, roleRecovery) {
+    const recovering = roleRecovery?.status === "waiting" || roleRecovery?.status === "retrying";
+    const paused = Boolean(current) && current.status === "stopped" && Boolean(current.id) && !recovering;
+    if (!paused) {
+        return undefined;
+    }
+    return {
+        paused: true,
+        reason: roleRecovery?.status === "failed" ? "role-recovery-failed" : "stopped-no-next-turn",
+        role: current.activeRole,
+        since: current.stoppedAt ?? current.lastTurnEndedAt
+    };
+}
 function normalizeRoundFile(input, taskSlug, updatedAt) {
     const legacy = input;
     return {

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

@@ -0,0 +1,91 @@
+import { CORE_VCM_ROLE_DEFINITIONS, GATE_REVIEWER_ROLE_DEFINITION, VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const ONE_CLICK_SESSION_COLS = 100;
+const ONE_CLICK_SESSION_ROWS = 28;
+export function createTaskLaunchService(deps) {
+    async function assertNoExistingRoleSessions(repoRoot, taskSlug) {
+        const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
+        if (sessions.some((session) => VCM_ROLE_NAMES.some((role) => role === session.role))) {
+            throw new VcmError({
+                code: "TASK_ONE_CLICK_REQUIRES_FRESH_START",
+                message: "One-click start is only available before any role session has started.",
+                statusCode: 409
+            });
+        }
+    }
+    async function applyOrchestrationMode(repoRoot, taskSlug, mode) {
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        return deps.messageService.updateOrchestrationState({
+            repoRoot,
+            stateRepoRoot: getTaskRuntimeRepoRoot(task),
+            stateRoot: config.stateRoot,
+            taskSlug,
+            mode
+        });
+    }
+    function composeRoleDefinitions(gateReviewerEnabled) {
+        return [
+            ...CORE_VCM_ROLE_DEFINITIONS,
+            ...(gateReviewerEnabled ? [GATE_REVIEWER_ROLE_DEFINITION] : [])
+        ];
+    }
+    // Skip a running role, resume one that has a prior Claude session, otherwise
+    // start it fresh — using the launch-template entry's permission/model/effort.
+    async function launchRole(repoRoot, taskSlug, role, roleTemplate) {
+        const sessionInput = {
+            cols: ONE_CLICK_SESSION_COLS,
+            rows: ONE_CLICK_SESSION_ROWS,
+            permissionMode: roleTemplate.permissionMode,
+            model: roleTemplate.model,
+            effort: roleTemplate.effort
+        };
+        const existing = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+        if (existing?.status === "running") {
+            return;
+        }
+        if (existing?.claudeSessionId) {
+            await deps.sessionService.resumeRoleSession(repoRoot, taskSlug, role, sessionInput);
+            return;
+        }
+        await deps.sessionService.startRoleSession(repoRoot, taskSlug, role, sessionInput);
+    }
+    return {
+        async startTaskRoleSessions(repoRoot, input) {
+            const { taskSlug, requireFreshStart } = input;
+            if (requireFreshStart) {
+                await assertNoExistingRoleSessions(repoRoot, taskSlug);
+            }
+            const preferences = await deps.appSettings.getPreferences();
+            const template = preferences.launchTemplate;
+            const orchestration = await applyOrchestrationMode(repoRoot, taskSlug, template.autoOrchestration ? "auto" : "manual");
+            const gateReview = await deps.appSettings.getGateReviewSettings(repoRoot, taskSlug);
+            const roleDefinitions = composeRoleDefinitions(gateReview.enabled);
+            const startedRoles = [];
+            for (const definition of roleDefinitions) {
+                try {
+                    await launchRole(repoRoot, taskSlug, definition.name, template.roles[definition.name]);
+                    startedRoles.push(definition.name);
+                }
+                catch (cause) {
+                    throw partialStartError(definition.name, startedRoles, cause);
+                }
+            }
+            const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
+            return { taskSlug, orchestration, startedRoles, sessions };
+        }
+    };
+}
+function partialStartError(failedRole, startedRoles, cause) {
+    return new VcmError({
+        code: "TASK_ONE_CLICK_PARTIAL_START",
+        message: `${failedRole} failed to start.`,
+        statusCode: 409,
+        hint: errorMessage(cause),
+        details: { startedRoles: [...startedRoles], failedRole }
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}