vibe-coding-master 0.4.9 → 0.4.11

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/cli/install-vcm-harness.js

@@ -40,6 +40,7 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "CwdChanged", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
 const AGENT_FRONTMATTER = {

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,30 @@ 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,
+            eventName,
+            taskSlug: context.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0
+        };
+    }
+    async function processCwdChangedHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        if (eventName !== "CwdChanged") {
+            throwUnsupportedEvent(eventName);
+        }
+        const context = await getHookContext(input);
+        const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
+            taskSlug: context.taskSlug,
+            role: input.role,
+            eventName,
+            claudeSessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
         return {
             ok: true,
@@ -270,7 +293,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,
@@ -431,6 +454,9 @@ export function createClaudeHookService(deps) {
             if (eventName === "PostCompact") {
                 return processPostCompactHook(input);
             }
+            if (eventName === "CwdChanged") {
+                return processCwdChangedHook(input);
+            }
             // Legacy combined endpoint: the installed hook discards the response,
             // so a block decision could not be enforced. Never block here.
             return processStopHook(input, { allowBlock: false });
@@ -448,14 +474,18 @@ 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"
+        || value === "CwdChanged") {
         return value;
     }
     throw new VcmError({
         code: "HOOK_EVENT_UNSUPPORTED",
         message: `Unsupported Claude Code hook event: ${String(value)}`,
         statusCode: 400,
-        hint: "VCM accepts UserPromptSubmit, Stop, StopFailure, and PostCompact hooks only."
+        hint: "VCM accepts UserPromptSubmit, Stop, StopFailure, PostCompact, and CwdChanged hooks only."
     });
 }
 function throwUnsupportedEvent(eventName) {

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

@@ -41,6 +41,7 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "CwdChanged", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
 const HARNESS_FILES = [
@@ -1420,7 +1421,7 @@ async function clearHarnessBootstrapRunState(fs, repoRoot) {
     await fs.removePath?.(resolveHarnessPath(repoRoot, BOOTSTRAP_SESSION_PATH), { force: true });
 }
 function isHarnessBootstrapHookEvent(value) {
-    return value === "Stop" || value === "StopFailure" || value === "UserPromptSubmit" || value === "PostCompact";
+    return value === "Stop" || value === "StopFailure" || value === "UserPromptSubmit" || value === "PostCompact" || value === "CwdChanged";
 }
 function matchesBootstrapRunState(state, input) {
     if (state.sessionId && input.sessionId && state.sessionId !== input.sessionId) {

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,103 @@ 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),
+            cwdMigrationTarget: targetCwd,
+            cwdMigrationPending: true,
+            lastCwdMigrationAt: timestamp,
+            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 +612,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 +649,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) {
@@ -547,16 +681,19 @@ export function createSessionService(deps) {
             const timestamp = now();
             const isTurnEnd = isTurnEndHook(input.eventName);
             const isCompact = isCompactHook(input.eventName);
+            const isCwdChanged = isCwdChangedHook(input.eventName);
             const updated = {
                 ...current,
                 claudeSessionId: input.sessionId ?? current.claudeSessionId,
                 transcriptPath: input.transcriptPath ?? current.transcriptPath,
                 cwd: input.cwd ?? current.cwd,
-                activityStatus: isTurnEnd ? "idle" : isCompact ? current.activityStatus : "running",
+                activityStatus: isTurnEnd ? "idle" : (isCompact || isCwdChanged) ? current.activityStatus : "running",
                 lastHookEventAt: timestamp,
                 lastTurnEndedAt: isTurnEnd ? timestamp : current.lastTurnEndedAt,
-                lastTurnStartedAt: isTurnEnd || isCompact ? current.lastTurnStartedAt : timestamp,
+                lastTurnStartedAt: isTurnEnd || isCompact || isCwdChanged ? current.lastTurnStartedAt : timestamp,
                 lastCompactAt: isCompact ? timestamp : current.lastCompactAt,
+                cwdMigrationPending: isCwdChanged ? false : current.cwdMigrationPending,
+                cwdMigrationTarget: isCwdChanged ? undefined : current.cwdMigrationTarget,
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);
@@ -602,6 +739,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 +776,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) {
@@ -644,16 +808,19 @@ export function createSessionService(deps) {
             const timestamp = now();
             const isTurnEnd = isTurnEndHook(input.eventName);
             const isCompact = isCompactHook(input.eventName);
+            const isCwdChanged = isCwdChangedHook(input.eventName);
             const updated = {
                 ...current,
                 claudeSessionId: input.sessionId ?? current.claudeSessionId,
                 transcriptPath: input.transcriptPath ?? current.transcriptPath,
                 cwd: input.cwd ?? current.cwd,
-                activityStatus: isTurnEnd ? "idle" : isCompact ? current.activityStatus : "running",
+                activityStatus: isTurnEnd ? "idle" : (isCompact || isCwdChanged) ? current.activityStatus : "running",
                 lastHookEventAt: timestamp,
                 lastTurnEndedAt: isTurnEnd ? timestamp : current.lastTurnEndedAt,
-                lastTurnStartedAt: isTurnEnd || isCompact ? current.lastTurnStartedAt : timestamp,
+                lastTurnStartedAt: isTurnEnd || isCompact || isCwdChanged ? current.lastTurnStartedAt : timestamp,
                 lastCompactAt: isCompact ? timestamp : current.lastCompactAt,
+                cwdMigrationPending: isCwdChanged ? false : current.cwdMigrationPending,
+                cwdMigrationTarget: isCwdChanged ? undefined : current.cwdMigrationTarget,
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);
@@ -827,17 +994,20 @@ export function createSessionService(deps) {
                 const timestamp = now();
                 const isTurnEnd = isTurnEndHook(input.eventName);
                 const isCompact = isCompactHook(input.eventName);
+                const isCwdChanged = isCwdChangedHook(input.eventName);
                 const updated = {
                     ...current,
                     taskSlug: PROJECT_GATE_REVIEWER_SCOPE,
                     claudeSessionId: input.sessionId ?? current.claudeSessionId,
                     transcriptPath: input.transcriptPath ?? current.transcriptPath,
                     cwd: input.cwd ?? current.cwd,
-                    activityStatus: isTurnEnd ? "idle" : isCompact ? current.activityStatus : "running",
+                    activityStatus: isTurnEnd ? "idle" : (isCompact || isCwdChanged) ? current.activityStatus : "running",
                     lastHookEventAt: timestamp,
                     lastTurnEndedAt: isTurnEnd ? timestamp : current.lastTurnEndedAt,
-                    lastTurnStartedAt: isTurnEnd || isCompact ? current.lastTurnStartedAt : timestamp,
+                    lastTurnStartedAt: isTurnEnd || isCompact || isCwdChanged ? current.lastTurnStartedAt : timestamp,
                     lastCompactAt: isCompact ? timestamp : current.lastCompactAt,
+                    cwdMigrationPending: isCwdChanged ? false : current.cwdMigrationPending,
+                    cwdMigrationTarget: isCwdChanged ? undefined : current.cwdMigrationTarget,
                     updatedAt: timestamp
                 };
                 deps.registry.upsert(updated);
@@ -869,16 +1039,19 @@ export function createSessionService(deps) {
             const timestamp = now();
             const isTurnEnd = isTurnEndHook(input.eventName);
             const isCompact = isCompactHook(input.eventName);
+            const isCwdChanged = isCwdChangedHook(input.eventName);
             const updated = {
                 ...current,
                 claudeSessionId: input.sessionId ?? current.claudeSessionId,
                 transcriptPath: input.transcriptPath ?? current.transcriptPath,
                 cwd: input.cwd ?? current.cwd,
-                activityStatus: isTurnEnd ? "idle" : isCompact ? current.activityStatus : "running",
+                activityStatus: isTurnEnd ? "idle" : (isCompact || isCwdChanged) ? current.activityStatus : "running",
                 lastHookEventAt: timestamp,
                 lastTurnEndedAt: isTurnEnd ? timestamp : current.lastTurnEndedAt,
-                lastTurnStartedAt: isTurnEnd || isCompact ? current.lastTurnStartedAt : timestamp,
+                lastTurnStartedAt: isTurnEnd || isCompact || isCwdChanged ? current.lastTurnStartedAt : timestamp,
                 lastCompactAt: isCompact ? timestamp : current.lastCompactAt,
+                cwdMigrationPending: isCwdChanged ? false : current.cwdMigrationPending,
+                cwdMigrationTarget: isCwdChanged ? undefined : current.cwdMigrationTarget,
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);
@@ -994,6 +1167,9 @@ function isTurnEndHook(eventName) {
 function isCompactHook(eventName) {
     return eventName === "PostCompact";
 }
+function isCwdChangedHook(eventName) {
+    return eventName === "CwdChanged";
+}
 function getRecoverableStatus(record) {
     if (!record.claudeSessionId) {
         return record.status === "running" ? "missing" : record.status;
@@ -1003,6 +1179,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;

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

@@ -18,6 +18,7 @@ const DEFAULT_PROFILE = "default";
 const DEFAULT_CHUNK_SOURCE_TOKEN_TARGET = 80000;
 const BOOTSTRAP_DEFAULT_LIMIT = 12;
 const MEMORY_TOTAL_LIMIT_BYTES = 80 * 1024;
+const MEMORY_INITIALIZED_MIN_FILES = 2;
 const MEMORY_FILE_NAMES = ["glossary.md", "style-guide.md", "project-context.md", "decisions.md"];
 const TRANSLATOR_ROLE = "translator";
 const FILE_BROWSER_DEFAULT_LIMIT = 200;
@@ -1552,14 +1553,15 @@ function isFileTranslationChunk(value) {
         typeof candidate.sourceLineEnd === "number";
 }
 async function isMemoryInitialized(repoRoot, fs) {
+    let initializedFiles = 0;
     for (const file of MEMORY_FILE_NAMES) {
         const content = await fs.readText(resolveRepoPath(repoRoot, `${MEMORY_DIR}/${file}`));
         const meaningfulLines = content.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#"));
         if (meaningfulLines.length > 0) {
-            return true;
+            initializedFiles += 1;
         }
     }
-    return false;
+    return initializedFiles >= MEMORY_INITIALIZED_MIN_FILES;
 }
 async function getMemoryUsage(repoRoot, fs) {
     let totalBytes = 0;