vibe-coding-master 0.4.38 → 0.4.39

package/dist/backend/api/runtime-state-routes.js

@@ -3,6 +3,7 @@ export function registerRuntimeStateRoutes(app, deps) {
     app.get("/api/projects/runtime-state", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const taskSlug = request.query.taskSlug?.trim();
+        const coordinated = await deps.runtimeCoordinator.reconcileProject(project.repoRoot, { taskSlug });
         const [translatorSession, translationState, harnessEngineerSession, harnessFeedbackState] = await Promise.all([
             deps.sessionService.getProjectTranslatorSession(project.repoRoot).then((session) => session ?? null),
             deps.translationWorkerService.getState(project.repoRoot, { visibility: "public" }),
@@ -16,7 +17,8 @@ export function registerRuntimeStateRoutes(app, deps) {
                 harnessEngineerSession,
                 harnessStatus: null,
                 harnessBootstrapStatus: null,
-                harnessFeedbackState
+                harnessFeedbackState,
+                gatewayStatus: coordinated.gatewayStatus
             };
         }
         try {
@@ -31,7 +33,8 @@ export function registerRuntimeStateRoutes(app, deps) {
                 harnessEngineerSession,
                 harnessStatus,
                 harnessBootstrapStatus,
-                harnessFeedbackState
+                harnessFeedbackState,
+                gatewayStatus: coordinated.gatewayStatus
             };
         }
         catch (error) {
@@ -42,7 +45,8 @@ export function registerRuntimeStateRoutes(app, deps) {
                     harnessEngineerSession,
                     harnessStatus: degradedHarnessStatus(error),
                     harnessBootstrapStatus: degradedBootstrapStatus(error),
-                    harnessFeedbackState
+                    harnessFeedbackState,
+                    gatewayStatus: coordinated.gatewayStatus
                 };
             }
             throw error;

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

@@ -613,6 +613,16 @@ export function createGatewayService(deps) {
         const settings = await deps.settings.updateSettings({ translationEnabled: enabled });
         return `Gateway translation ${settings.translationEnabled ? "on" : "off"}.`;
     }
+    async function enableGatewayTranslationRuntime() {
+        const preferences = await deps.appSettings.getPreferences();
+        if (preferences.translationEnabled && preferences.translationAutoSendEnabled) {
+            return;
+        }
+        await deps.appSettings.updatePreferences({
+            translationEnabled: true,
+            translationAutoSendEnabled: true
+        });
+    }
     async function startGateway() {
         const settings = await deps.settings.loadSettings();
         if (!toAccount(settings)) {
@@ -621,9 +631,14 @@ export function createGatewayService(deps) {
                 : "Gateway is not bound. Start QR login from desktop VCM first.";
         }
         if (settings.enabled) {
+            await enableGatewayTranslationRuntime();
             return "Gateway is already on.";
         }
-        const enabled = await syncDesktopContext(await deps.settings.updateSettings({ enabled: true }));
+        await enableGatewayTranslationRuntime();
+        const enabled = await syncDesktopContext(await deps.settings.updateSettings({
+            enabled: true,
+            translationEnabled: true
+        }));
         await ensurePolling();
         const lines = [
             "Gateway started.",
@@ -732,16 +747,25 @@ export function createGatewayService(deps) {
         },
         async getStatus() {
             const settings = await syncDesktopContext(await deps.settings.loadSettings());
+            if (settings.enabled) {
+                await enableGatewayTranslationRuntime();
+            }
             await ensurePolling();
             return deps.settings.expose(settings, isRunning());
         },
         async updateSettings(input) {
-            const updateInput = input.channel && input.baseUrl === undefined
+            const gatewayStartInput = input.enabled === true
+                ? { ...input, translationEnabled: true }
+                : input;
+            const updateInput = gatewayStartInput.channel && gatewayStartInput.baseUrl === undefined
                 ? {
-                    ...input,
-                    baseUrl: deps.channels.get(input.channel).defaultBaseUrl
+                    ...gatewayStartInput,
+                    baseUrl: deps.channels.get(gatewayStartInput.channel).defaultBaseUrl
                 }
-                : input;
+                : gatewayStartInput;
+            if (input.enabled === true) {
+                await enableGatewayTranslationRuntime();
+            }
             let settings = await deps.settings.updateSettings(updateInput);
             if (settings.enabled) {
                 settings = await syncDesktopContext(settings);
@@ -1025,7 +1049,8 @@ export function createGatewayService(deps) {
             }
             const cursorKey = `${input.taskSlug}:project-manager:${input.session.claudeSessionId}`;
             const cursor = settings.pushCursors[cursorKey];
-            const nextEvents = selectEventsAfterCursor(events, cursor?.lastTranscriptEventId);
+            const nextEvents = selectEventsAfterCursor(events, cursor?.lastTranscriptEventId)
+                .filter(isFinalTurnTextEvent);
             if (nextEvents.length === 0) {
                 return;
             }
@@ -1203,13 +1228,17 @@ async function readTranscriptTextEvents(transcriptPath) {
                 events.push({
                     id: event.id,
                     timestamp: event.timestamp,
-                    text: event.text
+                    text: event.text,
+                    stopReason: event.stopReason
                 });
             }
         }
     }
     return events;
 }
+function isFinalTurnTextEvent(event) {
+    return event.stopReason === "end_turn";
+}
 function selectEventsAfterCursor(events, cursorId) {
     if (events.length === 0) {
         return [];
@@ -1229,9 +1258,10 @@ function selectLatestTurnReply(events, session) {
     }
     const startMs = timestampMs(session.lastTurnStartedAt);
     const endMs = timestampMs(session.lastTurnEndedAt);
+    const finalEvents = events.filter(isFinalTurnTextEvent);
     const selected = startMs === undefined
-        ? events.slice(-1)
-        : events.filter((event) => {
+        ? finalEvents.slice(-1)
+        : finalEvents.filter((event) => {
             const eventMs = timestampMs(event.timestamp);
             return eventMs !== undefined
                 && eventMs >= startMs - 1_000

package/dist/backend/server.js

@@ -30,6 +30,7 @@ import { createSessionRegistry } from "./runtime/session-registry.js";
 import { createSessionService } from "./services/session-service.js";
 import { createMessageService } from "./services/message-service.js";
 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 { createTranslationService } from "./services/translation-service.js";
@@ -99,7 +100,8 @@ export async function createServer(deps, options = {}) {
         sessionService: deps.sessionService,
         translationWorkerService: deps.translationWorkerService,
         harnessService: deps.harnessService,
-        harnessFeedbackService: deps.harnessFeedbackService
+        harnessFeedbackService: deps.harnessFeedbackService,
+        runtimeCoordinator: deps.runtimeCoordinator
     });
     registerTaskRoutes(app, {
         projectService: deps.projectService,
@@ -290,6 +292,19 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         appSettings
     });
+    const runtimeCoordinator = createRuntimeCoordinatorService({
+        appSettings,
+        taskService,
+        sessionService,
+        translationService,
+        harnessService,
+        harnessFeedbackService,
+        roundService,
+        gatewayService,
+        async getStateRoot(repoRoot) {
+            return (await projectService.loadConfig(repoRoot)).stateRoot;
+        }
+    });
     const claudeHookService = createClaudeHookService({
         projectService,
         taskService,
@@ -328,6 +343,7 @@ export function createDefaultServerDeps(options = {}) {
         statusService,
         translationService,
         gatewayService,
+        runtimeCoordinator,
         runtime,
         diagnosticsService
     };

package/dist/backend/services/runtime-coordinator-service.js

@@ -0,0 +1,162 @@
+import { isVcmRoleName } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const EXPECTED_AUTO_RETROSPECTIVE_SKIP_CODES = new Set([
+    "HARNESS_FEEDBACK_ACTIVE",
+    "TASK_HARNESS_RETROSPECTIVE_EXISTS",
+    "TASK_FINAL_ACCEPTANCE_NOT_READY",
+    "HARNESS_ENGINEER_BUSY",
+    "HARNESS_ENGINEER_SESSION_MISSING",
+    "PROJECT_TOOL_TASK_REQUIRED"
+]);
+export function createRuntimeCoordinatorService(deps) {
+    const locks = new Map();
+    async function withRepoLock(repoRoot, run) {
+        const previous = locks.get(repoRoot) ?? Promise.resolve({
+            activeTask: null,
+            gatewayStatus: null
+        });
+        const next = previous.catch(() => ({
+            activeTask: null,
+            gatewayStatus: null
+        })).then(run);
+        locks.set(repoRoot, next);
+        try {
+            return await next;
+        }
+        finally {
+            if (locks.get(repoRoot) === next) {
+                locks.delete(repoRoot);
+            }
+        }
+    }
+    return {
+        reconcileProject(repoRoot, input = {}) {
+            return withRepoLock(repoRoot, async () => {
+                const [activeTask, gatewayStatus] = await Promise.all([
+                    resolveActiveTask(repoRoot, input.taskSlug),
+                    deps.gatewayService.getStatus().catch(() => null)
+                ]);
+                const preferences = await deps.appSettings.getPreferences();
+                if (!activeTask) {
+                    return { activeTask: null, gatewayStatus };
+                }
+                const taskRepoRoot = getTaskRuntimeRepoRoot(activeTask);
+                const harnessInitialized = await deps.harnessService.getHarnessStatus(taskRepoRoot)
+                    .then((status) => status.initialized)
+                    .catch(() => false);
+                await Promise.all([
+                    reconcileHarnessEngineer(repoRoot, activeTask),
+                    reconcileTranslator(repoRoot, activeTask, preferences.translationEnabled && harnessInitialized)
+                ]);
+                if (preferences.translationEnabled && harnessInitialized) {
+                    await startConversationTranslationListeners(repoRoot, activeTask);
+                }
+                else {
+                    await deps.translationService.stopTask(taskRepoRoot, activeTask.taskSlug).catch(() => undefined);
+                }
+                if (preferences.autoTaskHarnessReviewEnabled) {
+                    await maybeStartTaskHarnessRetrospective(repoRoot, activeTask);
+                }
+                return { activeTask, gatewayStatus };
+            });
+        }
+    };
+    async function resolveActiveTask(repoRoot, requestedTaskSlug) {
+        const tasks = await deps.taskService.listTasks(repoRoot);
+        const activeTasks = tasks.filter((task) => task.cleanupStatus !== "cleaned");
+        if (requestedTaskSlug) {
+            const requested = activeTasks.find((task) => task.taskSlug === requestedTaskSlug);
+            if (requested) {
+                return requested;
+            }
+        }
+        return activeTasks[0] ?? null;
+    }
+    async function reconcileHarnessEngineer(repoRoot, task) {
+        const existing = await deps.sessionService.getProjectHarnessEngineerSession(repoRoot);
+        if (!shouldAutoEnsureProjectToolSession(existing)) {
+            return;
+        }
+        await deps.sessionService.ensureProjectHarnessEngineerSession(repoRoot, {
+            taskSlug: task.taskSlug,
+            permissionMode: existing?.permissionMode,
+            model: existing?.model,
+            effort: existing?.effort
+        });
+    }
+    async function reconcileTranslator(repoRoot, task, enabled) {
+        if (!enabled) {
+            return;
+        }
+        const existing = await deps.sessionService.getProjectTranslatorSession(repoRoot);
+        if (!shouldAutoEnsureProjectToolSession(existing)) {
+            return;
+        }
+        await deps.sessionService.ensureProjectTranslatorSession(repoRoot, {
+            taskSlug: task.taskSlug,
+            permissionMode: existing?.permissionMode,
+            model: existing?.model,
+            effort: existing?.effort
+        });
+    }
+    function shouldAutoEnsureProjectToolSession(session) {
+        return Boolean(session && (session.status === "running" || session.claudeSessionId));
+    }
+    async function startConversationTranslationListeners(repoRoot, task) {
+        const translator = await deps.sessionService.getProjectTranslatorSession(repoRoot);
+        if (translator?.status !== "running") {
+            return;
+        }
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const sessions = await deps.sessionService.listRoleSessions(repoRoot, task.taskSlug);
+        await Promise.all(sessions
+            .filter((session) => session.status === "running" && isVcmRoleName(session.role))
+            .map((session) => startConversationTranslationListener(repoRoot, taskRepoRoot, task.taskSlug, session.role)));
+    }
+    async function startConversationTranslationListener(repoRoot, taskRepoRoot, taskSlug, role) {
+        try {
+            await deps.translationService.startSession({
+                repoRoot,
+                taskRepoRoot,
+                taskSlug,
+                role
+            });
+        }
+        catch (error) {
+            if (error instanceof VcmError && error.code === "SESSION_NOT_RUNNING") {
+                return;
+            }
+            throw error;
+        }
+    }
+    async function maybeStartTaskHarnessRetrospective(repoRoot, task) {
+        const stateRoot = await deps.getStateRoot(repoRoot);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const roundState = await deps.roundService.getSessionRoundState({
+            repoRoot,
+            stateRepoRoot: taskRepoRoot,
+            stateRoot,
+            taskSlug: task.taskSlug
+        });
+        if (roundState.status !== "stopped"
+            || !roundState.roundId
+            || roundState.roleRecovery?.status === "failed") {
+            return;
+        }
+        try {
+            await deps.harnessFeedbackService.startTaskRetrospective(repoRoot, {
+                taskSlug: task.taskSlug,
+                taskRepoRoot,
+                handoffDir: task.handoffDir,
+                trigger: "auto"
+            });
+        }
+        catch (error) {
+            if (error instanceof VcmError && (EXPECTED_AUTO_RETROSPECTIVE_SKIP_CODES.has(error.code) || error.statusCode === 409)) {
+                return;
+            }
+            throw error;
+        }
+    }
+}

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

@@ -14,6 +14,7 @@ const HARNESS_ENGINEER_DIR = ".ai/vcm/harness-engineer";
 const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
 const PROJECT_TRANSLATOR_SCOPE = "__project__";
 const PROJECT_HARNESS_ENGINEER_SCOPE = "__project_harness_engineer__";
+const PROJECT_TOOL_CD_ENTER_DELAY_MS = 500;
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function readCurrentHarnessRevision(repoRoot) {
@@ -301,7 +302,9 @@ export function createSessionService(deps) {
         }
         assertSafeCwdTarget(targetCwd);
         const timestamp = now();
-        await submitTerminalInput(deps.runtime, session.id, `/cd ${targetCwd}`);
+        await submitTerminalInput(deps.runtime, session.id, formatClaudeCdCommand(targetCwd), {
+            enterDelayMs: PROJECT_TOOL_CD_ENTER_DELAY_MS
+        });
         const updated = {
             ...session,
             cwd: targetCwd,
@@ -1260,3 +1263,6 @@ function normalizeClaudeEffort(value) {
     }
     return "default";
 }
+function formatClaudeCdCommand(targetCwd) {
+    return `/cd ${JSON.stringify(targetCwd)}`;
+}