vibe-coding-master 0.3.11 → 0.3.12

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

@@ -12,11 +12,13 @@ const CODEX_REVIEW_DIR = ".ai/vcm/codex-reviews";
 const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
 const CODEX_TRANSLATOR_DIR = ".ai/codex-translator";
 const CODEX_TRANSLATION_DIR = ".ai/vcm/translations";
+const CODEX_TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
+const CODEX_TRANSLATOR_LOG_PATH = ".ai/vcm/translations/codex-translator.log";
 const CODEX_TRANSLATOR_CONFIG_PATH = ".ai/codex-translator/config.toml";
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
-        const live = deps.registry.getByRole(taskSlug, role);
+        const live = toRoleSessionRecordView(getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role), deps.runtime);
         if (live && live.status === "running") {
             return live;
         }
@@ -24,8 +26,11 @@ export function createSessionService(deps) {
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
-        const persisted = await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
+        const persisted = await loadPersistedRoleRecordForRole(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, taskSlug, role);
         const isCodexRole = isCodexRoleName(role);
+        const isTranslator = role === CODEX_TRANSLATOR_ROLE;
+        const sessionRepoRoot = isTranslator ? repoRoot : taskRepoRoot;
+        const sessionLogPath = isTranslator ? CODEX_TRANSLATOR_LOG_PATH : paths.roleLogPaths[role];
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
         const model = isCodexRole
             ? normalizeCodexModel(input.model ?? persisted?.model)
@@ -48,7 +53,7 @@ export function createSessionService(deps) {
             ? persisted.transcriptPath
             : isCodexRole ? undefined : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
         const startCommand = isCodexRole
-            ? await buildCodexStartCommand(deps.fs, repoRoot, taskRepoRoot, role, launchMode, model, effort, deps.sandboxMode)
+            ? await buildCodexStartCommand(deps.fs, repoRoot, taskRepoRoot, role, launchMode, model, effort, deps.sandboxMode, launchMode === "resume" && hasCapturedCodexSession(persisted) ? claudeSessionId : undefined)
             : {
                 ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
                 cwd: taskRepoRoot
@@ -61,14 +66,14 @@ export function createSessionService(deps) {
             cwd: startCommand.cwd,
             env: {
                 VCM_API_URL: deps.apiUrl,
-                VCM_TASK_REPO_ROOT: taskRepoRoot,
+                VCM_TASK_REPO_ROOT: sessionRepoRoot,
                 VCM_TASK_SLUG: taskSlug,
                 VCM_ROLE: role,
                 VCM_SESSION_ID: claudeSessionId
             },
             cols: input.cols,
             rows: input.rows,
-            logPath: resolveRepoPath(taskRepoRoot, paths.roleLogPaths[role])
+            logPath: resolveRepoPath(sessionRepoRoot, sessionLogPath)
         });
         const timestamp = now();
         const record = {
@@ -86,7 +91,7 @@ export function createSessionService(deps) {
             cwd: startCommand.cwd,
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
-            logPath: paths.roleLogPaths[role],
+            logPath: sessionLogPath,
             roleCommandPath: isDispatchableRole(role)
                 ? paths.roleCommandPaths[role]
                 : undefined,
@@ -97,7 +102,7 @@ export function createSessionService(deps) {
             exitCode: runtimeSession.exitCode
         };
         deps.registry.upsert(record);
-        await persistTaskSession(deps.fs, taskRepoRoot, config.stateRoot, record);
+        await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
         return record;
     }
     return {
@@ -128,7 +133,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
@@ -146,8 +151,8 @@ export function createSessionService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const record = deps.registry.getByRole(taskSlug, role)
-                ?? await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
+            const record = getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role)
+                ?? await loadPersistedRoleRecordForRole(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, taskSlug, role);
             if (!record) {
                 return undefined;
             }
@@ -160,8 +165,12 @@ export function createSessionService(deps) {
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const persistedTaskSession = await loadPersistedTaskSessionRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug);
             for (const role of ROLE_NAMES) {
-                const session = toRoleSessionRecordView(deps.registry.getByRole(taskSlug, role)
-                    ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record), deps.runtime);
+                const record = role === CODEX_TRANSLATOR_ROLE
+                    ? getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role)
+                        ?? await loadPersistedCodexTranslatorSession(deps.fs, repoRoot, taskSlug)
+                    : deps.registry.getByRole(taskSlug, role)
+                        ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
+                const session = toRoleSessionRecordView(record, deps.runtime);
                 if (session) {
                     sessions.push(session);
                 }
@@ -189,7 +198,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, input.taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         recordClaudeHookEvent(repoRoot, input) {
@@ -218,7 +227,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         async markRoleActivityIdle(repoRoot, taskSlug, role) {
@@ -236,7 +245,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         }
     };
@@ -263,7 +272,7 @@ function toRoleSessionRecordView(record, runtime) {
         exitCode: runtimeSession.exitCode
     };
 }
-async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, launchMode, selectedModel, selectedEffort, sandboxMode) {
+async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, launchMode, selectedModel, selectedEffort, sandboxMode, resumeSessionId) {
     const isTranslator = role === CODEX_TRANSLATOR_ROLE;
     const codexDir = resolveRepoPath(isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATOR_DIR : CODEX_DIR);
     const outputDir = resolveRepoPath(isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATION_DIR : CODEX_REVIEW_DIR);
@@ -278,7 +287,7 @@ async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, laun
     await fs.ensureDir(outputDir);
     const config = await loadCodexSessionConfig(fs, isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATOR_CONFIG_PATH : CODEX_CONFIG_PATH);
     const args = launchMode === "resume"
-        ? ["resume", "--last"]
+        ? resumeSessionId ? ["resume", resumeSessionId] : ["resume", "--last"]
         : [];
     args.push("--cd", codexDir);
     if (isDevContainerSandbox(sandboxMode)) {
@@ -307,6 +316,9 @@ async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, laun
         display: [config.command, ...args].map(formatDisplayArg).join(" ")
     };
 }
+function hasCapturedCodexSession(record) {
+    return Boolean(record?.lastHookEventAt || record?.transcriptPath);
+}
 function isDevContainerSandbox(value) {
     return value?.toLowerCase() === "devcontainer";
 }
@@ -353,6 +365,44 @@ function getHandoffArtifactPath(paths, role) {
     }
     return undefined;
 }
+function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
+    if (role !== CODEX_TRANSLATOR_ROLE) {
+        return registry.getByRole(taskSlug, role);
+    }
+    const candidates = registry.list().filter((session) => session.role === role);
+    const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
+    const scoped = live
+        ?? candidates.find((session) => session.taskSlug === taskSlug)
+        ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
+    return scopeProjectRoleSession(scoped, taskSlug);
+}
+function compareSessionUpdatedAtDesc(left, right) {
+    return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
+}
+function scopeProjectRoleSession(record, taskSlug) {
+    if (!record || record.role !== CODEX_TRANSLATOR_ROLE) {
+        return record;
+    }
+    return {
+        ...record,
+        taskSlug
+    };
+}
+async function loadPersistedRoleRecordForRole(fs, baseRepoRoot, taskRepoRoot, stateRoot, taskSlug, role) {
+    if (role === CODEX_TRANSLATOR_ROLE) {
+        return loadPersistedCodexTranslatorSession(fs, baseRepoRoot, taskSlug);
+    }
+    return loadPersistedRoleRecord(fs, taskRepoRoot, stateRoot, taskSlug, role);
+}
+async function loadPersistedCodexTranslatorSession(fs, repoRoot, taskSlug) {
+    const sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
+    if (!(await fs.pathExists(sessionPath))) {
+        return undefined;
+    }
+    const payload = await fs.readJson(sessionPath);
+    const record = normalizePersistedRoleRecord(isProjectRoleSessionFile(payload) ? payload.record : payload);
+    return scopeProjectRoleSession(record, taskSlug);
+}
 async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role) {
     const current = await loadPersistedTaskSessionRecord(fs, repoRoot, stateRoot, taskSlug);
     return normalizePersistedRoleRecord(current?.roles[role]?.record);
@@ -410,6 +460,27 @@ async function persistTaskSession(fs, repoRoot, stateRoot, session) {
         }
     });
 }
+async function persistRoleSessionRecord(fs, baseRepoRoot, taskRepoRoot, stateRoot, session) {
+    if (session.role === CODEX_TRANSLATOR_ROLE) {
+        await persistCodexTranslatorSession(fs, baseRepoRoot, session);
+        return;
+    }
+    await persistTaskSession(fs, taskRepoRoot, stateRoot, session);
+}
+async function persistCodexTranslatorSession(fs, repoRoot, session) {
+    await fs.writeJsonAtomic(resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH), {
+        version: 1,
+        role: session.role,
+        updatedAt: session.updatedAt,
+        record: {
+            ...session,
+            taskSlug: session.taskSlug
+        }
+    });
+}
+function isProjectRoleSessionFile(value) {
+    return "record" in value && typeof value.record === "object" && value.record !== null;
+}
 function createEmptyTaskSessionRecord(taskSlug, updatedAt) {
     return {
         version: 1,

package/docs/codex-translation-plan.md

@@ -364,7 +364,27 @@ management pattern:
 - persisted Codex session id
 - long-lived terminal session for follow-up discussion
 
-Session identity is fixed by base repository and target language:
+VCM persists the active translator session at:
+
+```text
+<baseRepoRoot>/.ai/vcm/translations/session.json
+```
+
+This record is project-level state, not task-level state. It stores the Codex
+session id, selected model, selected effort, terminal cwd, log path, and hook
+activity state needed to show `Resume` after VCM restarts or after the user opens
+another task. The embedded terminal `Restart` control must stop the current
+runtime process, create a fresh Codex session id, overwrite this record, and keep
+old translation outputs intact.
+
+When a Codex hook has captured the real Codex `session_id`, `Resume` must run
+`codex resume <session_id>` so it reconnects the same translator conversation.
+Before the first hook captures a real id, VCM may fall back to `codex resume
+--last`.
+
+Session identity is fixed by base repository. If VCM later supports multiple
+parallel target-language translator sessions, split this file into a
+target-language keyed session directory:
 
 - one Codex Translator session per `<baseRepoRoot> + targetLanguage`
 - different target languages must use different sessions to avoid terminology

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [