vibe-coding-master 0.4.10 → 0.4.12

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

@@ -32,7 +32,7 @@ export function registerTaskRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
         await stopRunningRoleSessions(deps, project.repoRoot, request.params.taskSlug);
-        await stopProjectToolSessions(deps, project.repoRoot);
+        await moveProjectToolSessionsToSafeCwd(deps, project.repoRoot);
         await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), request.params.taskSlug, { clearCache: true });
         deps.roundService.stopTask(request.params.taskSlug);
         return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
@@ -46,10 +46,10 @@ async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
         }
     }
 }
-async function stopProjectToolSessions(deps, repoRoot) {
+async function moveProjectToolSessionsToSafeCwd(deps, repoRoot) {
     await Promise.all([
-        ignoreMissingSession(deps.sessionService.stopProjectTranslatorSession(repoRoot)),
-        ignoreMissingSession(deps.sessionService.stopProjectHarnessEngineerSession(repoRoot))
+        ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
+        ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
     ]);
 }
 async function ignoreMissingSession(operation) {

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

@@ -526,7 +526,7 @@ export function createGatewayService(deps) {
         }
         const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
         await stopRunningRoleSessions(project.repoRoot, taskSlug);
-        await stopProjectToolSessions(project.repoRoot);
+        await moveProjectToolSessionsToSafeCwd(project.repoRoot);
         await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true });
         deps.roundService.stopTask(taskSlug);
         const result = await deps.taskService.cleanupTask(project.repoRoot, taskSlug, {
@@ -561,10 +561,10 @@ export function createGatewayService(deps) {
             }
         }
     }
-    async function stopProjectToolSessions(repoRoot) {
+    async function moveProjectToolSessionsToSafeCwd(repoRoot) {
         await Promise.all([
-            ignoreMissingSession(deps.sessionService.stopProjectTranslatorSession(repoRoot)),
-            ignoreMissingSession(deps.sessionService.stopProjectHarnessEngineerSession(repoRoot))
+            ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
+            ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
         ]);
     }
     async function ignoreMissingSession(operation) {

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

@@ -62,7 +62,7 @@ export function createClaudeHookService(deps) {
             eventName,
             sessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
         await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
         return {
@@ -81,7 +81,7 @@ export function createClaudeHookService(deps) {
             eventName,
             sessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
         await deps.harnessService?.recordHarnessBootstrapHook(context.project.repoRoot, {
             eventName,
@@ -129,7 +129,7 @@ export function createClaudeHookService(deps) {
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
         await deps.roundService.recordClaudeHookEvent({
             repoRoot: context.project.repoRoot,
@@ -250,7 +250,7 @@ export function createClaudeHookService(deps) {
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
         return {
             ok: true,
@@ -270,7 +270,7 @@ export function createClaudeHookService(deps) {
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
         await deps.roundService.recordClaudeHookEvent({
             repoRoot: context.project.repoRoot,
@@ -448,7 +448,10 @@ export function createClaudeHookService(deps) {
     };
 }
 function parseHookEvent(value) {
-    if (value === "UserPromptSubmit" || value === "Stop" || value === "StopFailure" || value === "PostCompact") {
+    if (value === "UserPromptSubmit"
+        || value === "Stop"
+        || value === "StopFailure"
+        || value === "PostCompact") {
         return value;
     }
     throw new VcmError({

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

@@ -209,7 +209,7 @@ export function createSessionService(deps) {
         const taskContext = await resolveProjectToolTaskContext(repoRoot, input, "Translator");
         const live = toRoleSessionRecordView(getRegisteredProjectTranslatorSession(deps.registry, deps.runtime), deps.runtime);
         if (live && live.status === "running") {
-            return withHarnessRevisionView(repoRoot, live);
+            return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, live, taskContext.taskRepoRoot));
         }
         const config = await deps.projectService.loadConfig(repoRoot);
         const persisted = await loadPersistedTranslatorSession(deps.fs, repoRoot);
@@ -228,10 +228,15 @@ export function createSessionService(deps) {
             });
         }
         await deps.fs.ensureDir(resolveRepoPath(repoRoot, TRANSLATION_DIR));
-        const transcriptPath = claudeTranscriptPath(taskContext.taskRepoRoot, claudeSessionId);
+        const launchCwd = launchMode === "resume"
+            ? persisted?.cwd ?? taskContext.taskRepoRoot
+            : taskContext.taskRepoRoot;
+        const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
+            ? persisted.transcriptPath
+            : claudeTranscriptPath(launchCwd, claudeSessionId);
         const startCommand = {
             ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
-            cwd: taskContext.taskRepoRoot
+            cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
             taskSlug: PROJECT_TRANSLATOR_SCOPE,
@@ -274,13 +279,13 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistTranslatorSession(deps.fs, repoRoot, record);
-        return withHarnessRevisionView(repoRoot, record);
+        return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot));
     }
     async function launchProjectHarnessEngineerSession(repoRoot, input, launchMode) {
         const taskContext = await resolveProjectToolTaskContext(repoRoot, input, "Harness Engineer");
         const live = toRoleSessionRecordView(getRegisteredProjectHarnessEngineerSession(deps.registry, deps.runtime), deps.runtime);
         if (live && live.status === "running") {
-            return withHarnessRevisionView(repoRoot, live);
+            return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, live, taskContext.taskRepoRoot));
         }
         const config = await deps.projectService.loadConfig(repoRoot);
         const persisted = await loadPersistedHarnessEngineerSession(deps.fs, repoRoot);
@@ -299,10 +304,15 @@ export function createSessionService(deps) {
             });
         }
         await deps.fs.ensureDir(resolveRepoPath(repoRoot, HARNESS_ENGINEER_DIR));
-        const transcriptPath = claudeTranscriptPath(taskContext.taskRepoRoot, claudeSessionId);
+        const launchCwd = launchMode === "resume"
+            ? persisted?.cwd ?? taskContext.taskRepoRoot
+            : taskContext.taskRepoRoot;
+        const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
+            ? persisted.transcriptPath
+            : claudeTranscriptPath(launchCwd, claudeSessionId);
         const startCommand = {
             ...deps.claude.buildRoleStartCommand(HARNESS_ENGINEER_ROLE, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
-            cwd: taskContext.taskRepoRoot
+            cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
             taskSlug: PROJECT_HARNESS_ENGINEER_SCOPE,
@@ -345,7 +355,7 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistHarnessEngineerSession(deps.fs, repoRoot, record);
-        return withHarnessRevisionView(repoRoot, record);
+        return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot));
     }
     async function resolveProjectToolTaskContext(repoRoot, input, roleLabel) {
         const taskSlug = input.taskSlug?.trim();
@@ -363,6 +373,100 @@ export function createSessionService(deps) {
             taskRepoRoot: getTaskRuntimeRepoRoot(task)
         };
     }
+    async function migrateRunningProjectToolSessionCwd(repoRoot, session, targetCwd) {
+        if (session.role !== TRANSLATOR_ROLE
+            && session.role !== HARNESS_ENGINEER_ROLE
+            && session.role !== GATE_REVIEWER_ROLE) {
+            return session;
+        }
+        if (samePath(session.cwd, targetCwd)) {
+            return session;
+        }
+        const runtimeSession = deps.runtime.getSession(session.id);
+        if (!runtimeSession || runtimeSession.status !== "running") {
+            return session;
+        }
+        assertSafeCwdTarget(targetCwd);
+        const timestamp = now();
+        await submitTerminalInput(deps.runtime, session.id, `/cd ${targetCwd}`);
+        const updated = {
+            ...session,
+            cwd: targetCwd,
+            previousCwd: session.cwd,
+            transcriptPath: claudeTranscriptPath(targetCwd, session.claudeSessionId),
+            updatedAt: timestamp
+        };
+        deps.registry.upsert(normalizeProjectScopedRecordForPersistence(updated));
+        await persistProjectScopedToolSession(repoRoot, updated);
+        return updated;
+    }
+    async function resumeProjectToolSessionAtCwd(repoRoot, session, targetCwd) {
+        const live = toRoleSessionRecordView(session.role === TRANSLATOR_ROLE
+            ? getRegisteredProjectTranslatorSession(deps.registry, deps.runtime)
+            : session.role === HARNESS_ENGINEER_ROLE
+                ? getRegisteredProjectHarnessEngineerSession(deps.registry, deps.runtime)
+                : getRegisteredProjectGateReviewerSession(deps.registry, deps.runtime), deps.runtime);
+        if (live?.status === "running") {
+            return migrateRunningProjectToolSessionCwd(repoRoot, live, targetCwd);
+        }
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const permissionMode = normalizeClaudePermissionMode(session.permissionMode);
+        const model = normalizeClaudeModel(session.model);
+        const effort = normalizeClaudeEffort(session.effort);
+        const launchCwd = session.cwd || targetCwd;
+        const startCommand = {
+            ...deps.claude.buildRoleStartCommand(session.role, config.claudeCommand, permissionMode, session.claudeSessionId, true, model, effort),
+            cwd: launchCwd
+        };
+        const runtimeSession = await deps.runtime.createSession({
+            taskSlug: normalizeProjectScopedRecordForPersistence(session).taskSlug,
+            role: session.role,
+            command: startCommand.command,
+            args: startCommand.args,
+            cwd: startCommand.cwd,
+            env: {
+                VCM_API_URL: deps.apiUrl,
+                VCM_TASK_REPO_ROOT: targetCwd,
+                VCM_TASK_SLUG: normalizeProjectScopedRecordForPersistence(session).taskSlug,
+                VCM_ROLE: session.role,
+                VCM_SESSION_ID: session.claudeSessionId
+            }
+        });
+        const timestamp = now();
+        const resumed = {
+            ...session,
+            id: runtimeSession.id,
+            status: runtimeSession.status,
+            activityStatus: "idle",
+            command: startCommand.display,
+            permissionMode,
+            model,
+            effort,
+            cwd: launchCwd,
+            pid: runtimeSession.pid,
+            startedAt: runtimeSession.startedAt,
+            updatedAt: timestamp,
+            lastOutputAt: runtimeSession.lastOutputAt,
+            exitCode: runtimeSession.exitCode,
+            transcriptPath: session.transcriptPath ?? claudeTranscriptPath(launchCwd, session.claudeSessionId)
+        };
+        deps.registry.upsert(normalizeProjectScopedRecordForPersistence(resumed));
+        await persistProjectScopedToolSession(repoRoot, resumed);
+        return migrateRunningProjectToolSessionCwd(repoRoot, resumed, targetCwd);
+    }
+    async function persistProjectScopedToolSession(repoRoot, session) {
+        if (session.role === GATE_REVIEWER_ROLE) {
+            await persistProjectGateReviewerSession(deps.fs, repoRoot, session);
+            return;
+        }
+        if (session.role === TRANSLATOR_ROLE) {
+            await persistTranslatorSession(deps.fs, repoRoot, session);
+            return;
+        }
+        if (session.role === HARNESS_ENGINEER_ROLE) {
+            await persistHarnessEngineerSession(deps.fs, repoRoot, session);
+        }
+    }
     async function notifyHarnessUpdatedForSession(repoRoot, session) {
         const runtimeSession = deps.runtime.getSession(session.id);
         if (!runtimeSession || runtimeSession.status !== "running") {
@@ -505,6 +609,23 @@ export function createSessionService(deps) {
             await persistTranslatorSession(deps.fs, repoRoot, updated);
             return updated;
         },
+        async moveProjectTranslatorSessionToSafeCwd(repoRoot) {
+            const existing = await this.getProjectTranslatorSession(repoRoot);
+            if (!existing) {
+                throw new VcmError({
+                    code: "SESSION_MISSING",
+                    message: "Translator session has not been started.",
+                    statusCode: 404
+                });
+            }
+            if (samePath(existing.cwd, repoRoot)) {
+                return existing;
+            }
+            return withHarnessRevisionView(repoRoot, await resumeProjectToolSessionAtCwd(repoRoot, {
+                ...existing,
+                taskSlug: PROJECT_TRANSLATOR_SCOPE
+            }, repoRoot));
+        },
         async restartProjectTranslatorSession(repoRoot, input = {}) {
             const existing = await this.getProjectTranslatorSession(repoRoot);
             if (!existing) {
@@ -525,6 +646,16 @@ export function createSessionService(deps) {
         async ensureProjectTranslatorSession(repoRoot, input = {}) {
             const existing = await this.getProjectTranslatorSession(repoRoot);
             if (existing?.status === "running") {
+                if (input.taskSlug) {
+                    return this.resumeProjectTranslatorSession(repoRoot, {
+                        taskSlug: input.taskSlug,
+                        permissionMode: input.permissionMode ?? existing.permissionMode,
+                        model: input.model ?? existing.model,
+                        effort: input.effort ?? existing.effort,
+                        cols: input.cols,
+                        rows: input.rows
+                    });
+                }
                 return existing;
             }
             if (existing?.claudeSessionId) {
@@ -602,6 +733,23 @@ export function createSessionService(deps) {
             await persistHarnessEngineerSession(deps.fs, repoRoot, updated);
             return updated;
         },
+        async moveProjectHarnessEngineerSessionToSafeCwd(repoRoot) {
+            const existing = await this.getProjectHarnessEngineerSession(repoRoot);
+            if (!existing) {
+                throw new VcmError({
+                    code: "SESSION_MISSING",
+                    message: "Harness Engineer session has not been started.",
+                    statusCode: 404
+                });
+            }
+            if (samePath(existing.cwd, repoRoot)) {
+                return existing;
+            }
+            return withHarnessRevisionView(repoRoot, await resumeProjectToolSessionAtCwd(repoRoot, {
+                ...existing,
+                taskSlug: PROJECT_HARNESS_ENGINEER_SCOPE
+            }, repoRoot));
+        },
         async restartProjectHarnessEngineerSession(repoRoot, input = {}) {
             const existing = await this.getProjectHarnessEngineerSession(repoRoot);
             if (!existing) {
@@ -622,6 +770,16 @@ export function createSessionService(deps) {
         async ensureProjectHarnessEngineerSession(repoRoot, input = {}) {
             const existing = await this.getProjectHarnessEngineerSession(repoRoot);
             if (existing?.status === "running") {
+                if (input.taskSlug) {
+                    return this.resumeProjectHarnessEngineerSession(repoRoot, {
+                        taskSlug: input.taskSlug,
+                        permissionMode: input.permissionMode ?? existing.permissionMode,
+                        model: input.model ?? existing.model,
+                        effort: input.effort ?? existing.effort,
+                        cols: input.cols,
+                        rows: input.rows
+                    });
+                }
                 return existing;
             }
             if (existing?.claudeSessionId) {
@@ -1003,6 +1161,18 @@ function getRecoverableStatus(record) {
     }
     return "resumable";
 }
+function samePath(left, right) {
+    return path.resolve(left) === path.resolve(right);
+}
+function assertSafeCwdTarget(targetCwd) {
+    if (!targetCwd.trim() || /[\r\n]/.test(targetCwd)) {
+        throw new VcmError({
+            code: "SESSION_CWD_INVALID",
+            message: "Session cwd target is invalid.",
+            statusCode: 400
+        });
+    }
+}
 function getHandoffArtifactPath(paths, role) {
     if (role === "architect") {
         return paths.architecturePlanPath;