vibe-coding-master 0.4.41 → 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/api/translation-routes.js

@@ -17,6 +17,17 @@ export function registerTranslationRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.translationService.pollSessionEvents(request.params.sessionId, Number(request.query.after ?? "1"), request.query.limit === undefined ? undefined : Number(request.query.limit), { repoRoot: project.repoRoot });
     });
+    app.get("/api/tasks/:taskSlug/translation/feed", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.translationService.pollTaskFeed({
+            repoRoot: project.repoRoot,
+            taskRepoRoot: getTaskRuntimeRepoRoot(task),
+            taskSlug: request.params.taskSlug,
+            after: Number(request.query.after ?? "1"),
+            limit: request.query.limit === undefined ? undefined : Number(request.query.limit)
+        });
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/translation/input", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);

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

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

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { isVcmRoleName } from "../../shared/constants.js";
 import { TRANSLATION_ENTRY_RETENTION_LIMIT } from "../../shared/types/translation.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -11,12 +12,14 @@ const TRANSLATION_PROVIDER = "claude-code";
 const TRANSLATION_MODEL = "translator";
 const OUTPUT_TRANSLATION_BATCH_DELAY_MS = 10000;
 const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
+const TRANSLATION_TASK_FEED_RETENTION_LIMIT = 2000;
 export function createTranslationService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `tr_${Date.now()}_${Math.random().toString(16).slice(2)}`);
     const outputBatchDelayMs = Math.max(0, deps.outputBatchDelayMs ?? OUTPUT_TRANSLATION_BATCH_DELAY_MS);
     const queues = createTranslationQueueRegistry();
     const sessionStates = new Map();
+    const taskFeeds = new Map();
     async function loadConfig() {
         const preferences = await deps.appSettings.getPreferences();
         return {
@@ -79,9 +82,49 @@ export function createTranslationService(deps) {
             createdAt: now()
         };
         state.events.push(event);
+        appendTaskFeedEvent(sessionId, state, event);
         void persistEvents(state);
         return event;
     }
+    function appendTaskFeedEvent(sessionId, state, event) {
+        if (!state.repoRoot || !state.taskSlug || !state.role) {
+            return;
+        }
+        const feed = getTaskFeed(state.repoRoot, state.taskSlug);
+        const sessionEventKey = getTaskFeedSessionEventKey(sessionId, event);
+        if (feed.seenSessionEvents.has(sessionEventKey)) {
+            return;
+        }
+        feed.seenSessionEvents.add(sessionEventKey);
+        feed.events.push({
+            seq: feed.nextSeq++,
+            sessionId,
+            role: state.role,
+            event
+        });
+        if (feed.events.length > TRANSLATION_TASK_FEED_RETENTION_LIMIT) {
+            feed.events = feed.events.slice(-TRANSLATION_TASK_FEED_RETENTION_LIMIT);
+        }
+    }
+    function syncTaskFeedFromSessionState(sessionId, state) {
+        for (const event of state.events) {
+            appendTaskFeedEvent(sessionId, state, event);
+        }
+    }
+    function getTaskFeed(repoRoot, taskSlug) {
+        const key = getTaskFeedKey(repoRoot, taskSlug);
+        const current = taskFeeds.get(key);
+        if (current) {
+            return current;
+        }
+        const created = {
+            events: [],
+            nextSeq: 1,
+            seenSessionEvents: new Set()
+        };
+        taskFeeds.set(key, created);
+        return created;
+    }
     async function prepareCache(input) {
         const state = getState(input.sessionId);
         state.repoRoot = input.repoRoot;
@@ -99,6 +142,7 @@ export function createTranslationService(deps) {
             state.cacheLoaded = true;
             pruneTranslationEntries(input.sessionId);
         }
+        syncTaskFeedFromSessionState(input.sessionId, state);
         await deps.fs.ensureDir(path.dirname(cachePath));
         return state;
     }
@@ -629,6 +673,43 @@ export function createTranslationService(deps) {
                 events
             };
         },
+        async pollTaskFeed(input) {
+            const cursor = Number.isFinite(input.after) ? Math.max(1, Math.floor(input.after)) : 1;
+            const maxEvents = Math.min(Math.max(1, Math.floor(input.limit ?? 500)), 1000);
+            const roleSessions = await deps.sessionService.listRoleSessions(input.repoRoot, input.taskSlug);
+            const feedSessions = [];
+            for (const roleSession of roleSessions) {
+                if (!isVcmRoleName(roleSession.role)) {
+                    continue;
+                }
+                const state = await prepareCache({
+                    repoRoot: input.taskRepoRoot,
+                    baseRepoRoot: input.repoRoot,
+                    taskSlug: input.taskSlug,
+                    role: roleSession.role,
+                    sessionId: roleSession.id
+                });
+                if (roleSession.status === "running") {
+                    startTranscriptTail(roleSession);
+                }
+                feedSessions.push({
+                    sessionId: roleSession.id,
+                    role: roleSession.role,
+                    status: state.status
+                });
+            }
+            const feed = getTaskFeed(input.taskRepoRoot, input.taskSlug);
+            const events = feed.events
+                .filter((event) => event.seq >= cursor)
+                .slice(0, maxEvents);
+            const nextCursor = events.length > 0 ? (events.at(-1)?.seq ?? cursor) + 1 : cursor;
+            return {
+                taskSlug: input.taskSlug,
+                nextCursor,
+                sessions: feedSessions,
+                events
+            };
+        },
         async recordConversationBoundary(input) {
             const config = await loadConfig();
             const state = await prepareCache({
@@ -1060,6 +1141,12 @@ function getTranscriptSessionKey(roleSession) {
         roleSession.transcriptPath
     ].join("\n");
 }
+function getTaskFeedKey(repoRoot, taskSlug) {
+    return `${repoRoot}\n${taskSlug}`;
+}
+function getTaskFeedSessionEventKey(sessionId, event) {
+    return `${sessionId}:${event.seq}`;
+}
 function formatStructuredTranscriptEvent(event) {
     if (event.kind === "question") {
         return event.question.questions.map((question, index) => {